toolcraft 0.0.26 → 0.0.33

package/node_modules/@poe-code/task-list/dist/backends/yaml-file.js

@@ -50,7 +50,8 @@ function parseQualifiedId(qualifiedId) {
     };
 }
 function descriptionFromTaskRecord(taskRecord) {
-    return typeof taskRecord.description === "string" ? taskRecord.description : "";
+    const description = getOwnEntry(taskRecord, "description");
+    return typeof description === "string" ? description : "";
 }
 function metadataFromTaskRecord(taskRecord) {
     const metadata = Object.create(null);
@@ -66,8 +67,8 @@ function createTask(list, id, taskRecord, sourcePath) {
         list,
         id,
         qualifiedId: `${list}/${id}`,
-        name: taskRecord.name,
-        state: taskRecord.state,
+        name: getOwnEntry(taskRecord, "name"),
+        state: getOwnEntry(taskRecord, "state"),
         description: descriptionFromTaskRecord(taskRecord),
         metadata: metadataFromTaskRecord(taskRecord),
         ...(sourcePath !== undefined && { sourcePath: path.resolve(sourcePath) })
@@ -163,18 +164,19 @@ function assertValidStoreRecord(store, filePath) {
     if (!isRecord(store)) {
         throw malformedStore(filePath, "store");
     }
-    if (store.$schema !== STORE_SCHEMA_ID) {
+    if (getOwnEntry(store, "$schema") !== STORE_SCHEMA_ID) {
         throw malformedStore(filePath, "$schema");
     }
-    if (store.kind !== STORE_KIND) {
+    if (getOwnEntry(store, "kind") !== STORE_KIND) {
         throw malformedStore(filePath, "kind");
     }
-    if (typeof store.version !== "number" ||
-        !Number.isInteger(store.version) ||
-        store.version !== STORE_VERSION) {
+    const version = getOwnEntry(store, "version");
+    if (typeof version !== "number" ||
+        !Number.isInteger(version) ||
+        version !== STORE_VERSION) {
         throw malformedStore(filePath, "version");
     }
-    if (!isRecord(store.lists)) {
+    if (!isRecord(getOwnEntry(store, "lists"))) {
         throw malformedStore(filePath, "lists");
     }
 }
@@ -182,31 +184,45 @@ function assertValidTaskRecord(taskRecord, list, id, validStates) {
     if (!isRecord(taskRecord)) {
         throw malformedTask(list, id, "task");
     }
-    if ("$schema" in taskRecord && taskRecord.$schema !== TASK_SCHEMA_ID) {
+    if (hasOwnTaskField(taskRecord, "$schema") && getOwnEntry(taskRecord, "$schema") !== TASK_SCHEMA_ID) {
         throw malformedTask(list, id, "$schema");
     }
-    if ("kind" in taskRecord && taskRecord.kind !== TASK_KIND) {
+    if (hasOwnTaskField(taskRecord, "kind") && getOwnEntry(taskRecord, "kind") !== TASK_KIND) {
         throw malformedTask(list, id, "kind");
     }
-    if ("version" in taskRecord) {
-        if (typeof taskRecord.version !== "number" ||
-            !Number.isInteger(taskRecord.version) ||
-            taskRecord.version !== TASK_VERSION) {
+    if (hasOwnTaskField(taskRecord, "version")) {
+        const version = getOwnEntry(taskRecord, "version");
+        if (typeof version !== "number" ||
+            !Number.isInteger(version) ||
+            version !== TASK_VERSION) {
             throw malformedTask(list, id, "version");
         }
     }
-    if (typeof taskRecord.name !== "string" || taskRecord.name.length === 0) {
+    const name = getOwnEntry(taskRecord, "name");
+    if (!hasOwnTaskField(taskRecord, "name") ||
+        typeof name !== "string" ||
+        name.length === 0) {
         throw malformedTask(list, id, "name");
     }
-    if (typeof taskRecord.state !== "string" || !validStates.has(taskRecord.state)) {
+    const state = getOwnEntry(taskRecord, "state");
+    if (!hasOwnTaskField(taskRecord, "state") ||
+        typeof state !== "string" ||
+        !validStates.has(state)) {
         throw malformedTask(list, id, "state");
     }
-    if ("description" in taskRecord && typeof taskRecord.description !== "string") {
+    if (hasOwnTaskField(taskRecord, "description") &&
+        typeof getOwnEntry(taskRecord, "description") !== "string") {
         throw malformedTask(list, id, "description");
     }
 }
+function hasOwnTaskField(taskRecord, key) {
+    return Object.prototype.hasOwnProperty.call(taskRecord, key);
+}
+function getOwnEntry(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}
 function validateStoreEntries(store, filePath, validStates) {
-    const lists = store.lists;
+    const lists = getOwnEntry(store, "lists");
     if (!isRecord(lists)) {
         throw malformedStore(filePath, "lists");
     }
@@ -247,10 +263,11 @@ async function readStore(fs, filePath, validStates) {
     };
 }
 function getListsRecord(store) {
-    return store.lists;
+    const lists = getOwnEntry(store, "lists");
+    return isRecord(lists) ? lists : {};
 }
 function getListRecord(store, list) {
-    const listRecord = getListsRecord(store)[list];
+    const listRecord = getOwnEntry(getListsRecord(store), list);
     return isRecord(listRecord) ? listRecord : undefined;
 }
 function getTaskRecord(store, list, id) {
@@ -546,7 +563,7 @@ export async function yamlFileBackend(deps) {
         const result = [];
         const listNames = sortStrings(Object.keys(getListsRecord(store)));
         for (const listName of listNames) {
-            const listRecord = getListsRecord(store)[listName];
+            const listRecord = getOwnEntry(getListsRecord(store), listName);
             if (!isRecord(listRecord))
                 continue;
             const entries = Object.entries(listRecord)

package/node_modules/@poe-code/task-list/dist/move.js

@@ -115,7 +115,7 @@ async function applyState(tasks, created, events) {
     return task;
 }
 function readOnlySourceOptions(options) {
-    if (!("create" in options)) {
+    if (!hasOwnProperty(options, "create")) {
         return options;
     }
     return { ...options, create: false };
@@ -213,3 +213,6 @@ function createTokenBucket(rate) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function hasOwnProperty(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}

package/node_modules/@poe-code/task-list/dist/open.js

@@ -13,48 +13,70 @@ function createDefaultFs() {
     return fsPromises;
 }
 export async function openTaskList(options) {
-    switch (options.type) {
+    const type = getOwnProperty(options, "type");
+    switch (type) {
         case "markdown-dir":
         case "yaml-file":
             return openFileBackend(options);
         case "gh-issues":
             return openGhIssuesBackend(options);
         default:
-            throw new Error(`Unknown task list backend type "${options.type}".`);
+            throw new Error(`Unknown task list backend type "${String(type)}".`);
     }
 }
 async function openFileBackend(options) {
-    const factory = backendFactories[options.type];
-    const stateMachine = resolveStateMachine(options.stateMachine);
+    const type = getOwnProperty(options, "type");
+    const factory = backendFactories[type];
+    const stateMachine = resolveStateMachine(getOwnProperty(options, "stateMachine"));
     validateMachine(stateMachine);
-    const markdownOptions = options.type === "markdown-dir" ? options : undefined;
+    const markdownOptions = type === "markdown-dir" ? options : undefined;
+    const defaults = getOwnProperty(options, "defaults");
     const deps = {
-        path: options.path,
+        path: getOwnProperty(options, "path"),
         defaults: {
-            metadata: { ...(options.defaults?.metadata ?? {}) }
+            metadata: readDefaultMetadata(defaults)
         },
-        singleList: markdownOptions?.singleList,
-        frontmatterMode: markdownOptions?.frontmatterMode ?? "strict",
-        create: options.create ?? false,
-        fs: options.fs ?? createDefaultFs(),
+        singleList: markdownOptions === undefined
+            ? undefined
+            : getOwnProperty(markdownOptions, "singleList"),
+        frontmatterMode: markdownOptions === undefined
+            ? "strict"
+            : (getOwnProperty(markdownOptions, "frontmatterMode") ?? "strict"),
+        create: getOwnProperty(options, "create") ?? false,
+        fs: getOwnProperty(options, "fs") ?? createDefaultFs(),
         stateMachine
     };
     return factory(deps);
 }
 async function openGhIssuesBackend(options) {
-    const token = await resolveAuth({ explicitToken: options.auth?.token });
+    const auth = getOwnProperty(options, "auth");
+    const explicitToken = auth && hasOwnProperty(auth, "token") ? auth.token : undefined;
     const endpoint = resolveEndpoint();
+    const defaults = getOwnProperty(options, "defaults");
     return ghIssuesBackend({
-        repo: options.repo,
-        project: options.project,
-        filter: options.filter,
-        state: options.state,
-        stateMachine: options.stateMachine,
+        repo: getOwnProperty(options, "repo"),
+        project: getOwnProperty(options, "project"),
+        filter: getOwnProperty(options, "filter"),
+        state: getOwnProperty(options, "state"),
+        stateMachine: getOwnProperty(options, "stateMachine"),
         defaults: {
-            metadata: { ...(options.defaults?.metadata ?? {}) }
+            metadata: readDefaultMetadata(defaults)
         },
-        token,
+        token: await resolveAuth({ explicitToken }),
         endpoint,
-        fetch: options.fetch
+        fetch: getOwnProperty(options, "fetch")
     });
 }
+function readDefaultMetadata(defaults) {
+    const metadata = defaults === undefined ? undefined : getOwnProperty(defaults, "metadata");
+    return isRecord(metadata) ? { ...metadata } : {};
+}
+function getOwnProperty(value, name) {
+    return hasOwnProperty(value, name) ? value[name] : undefined;
+}
+function hasOwnProperty(value, name) {
+    return Object.prototype.hasOwnProperty.call(value, name);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/node_modules/@poe-code/task-list/dist/state-machine.js

@@ -14,27 +14,27 @@ export function validateMachine(machine) {
     if (!isRecord(machine)) {
         throw new TypeError("State machine must be an object.");
     }
-    if (!isStateList(machine.states)) {
+    if (!hasOwnRecordField(machine, "states") || !isStateList(machine.states)) {
         throw new TypeError("State machine states must be a string array.");
     }
     const states = new Set(machine.states);
-    if (typeof machine.initial !== "string") {
+    if (!hasOwnRecordField(machine, "initial") || typeof machine.initial !== "string") {
         throw new TypeError("State machine initial must be a string.");
     }
     if (!states.has(machine.initial)) {
         throw new Error(`Initial state "${machine.initial}" is not declared.`);
     }
-    if (!isRecord(machine.events)) {
+    if (!hasOwnRecordField(machine, "events") || !isRecord(machine.events)) {
         throw new TypeError("State machine events must be an object.");
     }
     for (const [eventName, event] of Object.entries(machine.events)) {
         if (!isRecord(event)) {
             throw new TypeError(`Event "${eventName}" must be an object.`);
         }
-        if (event.from !== "*" && !isStateList(event.from)) {
+        if (!hasOwnRecordField(event, "from") || (event.from !== "*" && !isStateList(event.from))) {
             throw new TypeError(`Event "${eventName}" has an invalid "from" definition.`);
         }
-        if (typeof event.to !== "string") {
+        if (!hasOwnRecordField(event, "to") || typeof event.to !== "string") {
             throw new TypeError(`Event "${eventName}" target state must be a string.`);
         }
         if (!states.has(event.to)) {
@@ -49,6 +49,9 @@ export function validateMachine(machine) {
         }
     }
 }
+function hasOwnRecordField(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
 export function eventsFromState(machine, fromState) {
     const events = [];
     for (const [eventName, event] of Object.entries(machine.events)) {

package/node_modules/auth-store/dist/create-secret-store.js

@@ -27,7 +27,7 @@ export function createSecretStore(input) {
 }
 function resolveBackend(input) {
     const envVar = input.backendEnvVar ?? DEFAULT_BACKEND_ENV_VAR;
-    const configuredBackend = input.backend ?? input.env?.[envVar] ?? process.env[envVar];
+    const configuredBackend = input.backend ?? getOwnEnvValue(input.env, envVar) ?? getOwnEnvValue(process.env, envVar);
     if (configuredBackend === "keychain") {
         return "keychain";
     }
@@ -36,3 +36,8 @@ function resolveBackend(input) {
     }
     throw new Error(`Unsupported auth store backend: ${configuredBackend}`);
 }
+function getOwnEnvValue(env, key) {
+    return env !== undefined && Object.prototype.hasOwnProperty.call(env, key)
+        ? env[key]
+        : undefined;
+}

package/node_modules/auth-store/dist/encrypted-file-store.d.ts

@@ -42,6 +42,6 @@ export declare class EncryptedFileStore implements SecretStore {
     get(): Promise<string | null>;
     set(value: string): Promise<void>;
     delete(): Promise<void>;
-    private assertRegularCredentialPath;
+    private assertCredentialPathHasNoSymbolicLinks;
     private getEncryptionKey;
 }

package/node_modules/auth-store/dist/encrypted-file-store.js

@@ -1,7 +1,8 @@
-import { createCipheriv, createDecipheriv, randomBytes, scrypt } from "node:crypto";
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID, scrypt } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { homedir, hostname, userInfo } from "node:os";
 import path from "node:path";
+import { hasOwnErrorCode } from "./error-codes.js";
 const derivedKeyCache = new Map();
 const ENCRYPTION_ALGORITHM = "aes-256-gcm";
 const ENCRYPTION_VERSION = 1;
@@ -9,7 +10,6 @@ const ENCRYPTION_KEY_BYTES = 32;
 const ENCRYPTION_IV_BYTES = 12;
 const ENCRYPTION_AUTH_TAG_BYTES = 16;
 const ENCRYPTION_FILE_MODE = 0o600;
-let temporaryFileSequence = 0;
 export class EncryptedFileStore {
     fs;
     filePath;
@@ -35,7 +35,7 @@ export class EncryptedFileStore {
         this.getRandomBytes = input.getRandomBytes ?? randomBytes;
     }
     async get() {
-        await this.assertRegularCredentialPath();
+        await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
         let rawDocument;
         try {
             rawDocument = await this.fs.readFile(this.filePath, "utf8");
@@ -69,7 +69,7 @@ export class EncryptedFileStore {
         }
     }
     async set(value) {
-        await this.assertRegularCredentialPath();
+        await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
         const key = await this.getEncryptionKey();
         const iv = this.getRandomBytes(ENCRYPTION_IV_BYTES);
         const cipher = createCipheriv(ENCRYPTION_ALGORITHM, key, iv);
@@ -85,26 +85,29 @@ export class EncryptedFileStore {
             ciphertext: ciphertext.toString("base64")
         };
         await this.fs.mkdir(path.dirname(this.filePath), { recursive: true });
-        await this.assertRegularCredentialPath();
-        const temporaryPath = `${this.filePath}.${process.pid}.${temporaryFileSequence++}.tmp`;
+        await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
+        const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let temporaryCreated = false;
         try {
+            await this.assertCredentialPathHasNoSymbolicLinks(temporaryPath);
             await this.fs.writeFile(temporaryPath, JSON.stringify(document), {
                 encoding: "utf8",
                 flag: "wx",
                 mode: ENCRYPTION_FILE_MODE
             });
+            temporaryCreated = true;
             await this.fs.chmod(temporaryPath, ENCRYPTION_FILE_MODE);
             await this.fs.rename(temporaryPath, this.filePath);
         }
         catch (error) {
-            if (!isAlreadyExistsError(error)) {
+            if (temporaryCreated || !isAlreadyExistsError(error)) {
                 await removeIfPresent(this.fs, temporaryPath).catch(() => undefined);
             }
             throw error;
         }
     }
     async delete() {
-        await this.assertRegularCredentialPath();
+        await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
         try {
             await this.fs.unlink(this.filePath);
         }
@@ -114,8 +117,8 @@ export class EncryptedFileStore {
             }
         }
     }
-    async assertRegularCredentialPath() {
-        const resolvedPath = path.resolve(this.filePath);
+    async assertCredentialPathHasNoSymbolicLinks(targetPath) {
+        const resolvedPath = path.resolve(targetPath);
         const protectedPaths = getProtectedCredentialPaths(resolvedPath, this.symbolicLinkCheckStartPath);
         for (const currentPath of protectedPaths) {
             try {
@@ -179,12 +182,6 @@ async function removeIfPresent(fileSystem, filePath) {
         }
     }
 }
-function isAlreadyExistsError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "EEXIST");
-}
 function defaultMachineIdentity() {
     return {
         hostname: hostname(),
@@ -222,19 +219,23 @@ function parseEncryptedDocument(raw) {
         if (!isRecord(parsed)) {
             return null;
         }
-        if (parsed.version !== ENCRYPTION_VERSION) {
+        const version = getOwnEntry(parsed, "version");
+        const iv = getOwnEntry(parsed, "iv");
+        const authTag = getOwnEntry(parsed, "authTag");
+        const ciphertext = getOwnEntry(parsed, "ciphertext");
+        if (version !== ENCRYPTION_VERSION) {
             return null;
         }
-        if (typeof parsed.iv !== "string" ||
-            typeof parsed.authTag !== "string" ||
-            typeof parsed.ciphertext !== "string") {
+        if (typeof iv !== "string" ||
+            typeof authTag !== "string" ||
+            typeof ciphertext !== "string") {
             return null;
         }
         return {
-            version: parsed.version,
-            iv: parsed.iv,
-            authTag: parsed.authTag,
-            ciphertext: parsed.ciphertext
+            version,
+            iv,
+            authTag,
+            ciphertext
         };
     }
     catch {
@@ -244,9 +245,12 @@ function parseEncryptedDocument(raw) {
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function getOwnEntry(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}
 function isNotFoundError(error) {
-    return Boolean(error &&
-        typeof error === "object" &&
-        "code" in error &&
-        error.code === "ENOENT");
+    return hasOwnErrorCode(error, "ENOENT");
+}
+function isAlreadyExistsError(error) {
+    return hasOwnErrorCode(error, "EEXIST");
 }

package/node_modules/auth-store/dist/error-codes.d.ts

@@ -0,0 +1 @@
+export declare function hasOwnErrorCode(error: unknown, code: string): boolean;

package/node_modules/auth-store/dist/error-codes.js

@@ -0,0 +1,5 @@
+export function hasOwnErrorCode(error, code) {
+    return (error instanceof Error &&
+        Object.prototype.hasOwnProperty.call(error, "code") &&
+        error.code === code);
+}

package/node_modules/auth-store/dist/keychain-store.js

@@ -12,8 +12,8 @@ export class KeychainStore {
     }
     async get() {
         const result = await this.executeSecurityCommand(["find-generic-password", "-s", this.service, "-a", this.account, "-w"], "read secret from macOS Keychain");
-        if (result.exitCode === 0) {
-            return stripTrailingLineBreak(result.stdout);
+        if (getCommandExitCode(result) === 0) {
+            return stripTrailingLineBreak(getCommandOutput(result, "stdout"));
         }
         if (isKeychainEntryNotFound(result)) {
             return null;
@@ -33,13 +33,13 @@ export class KeychainStore {
             "-U",
             "-w"
         ], "store secret in macOS Keychain", { stdin: value });
-        if (result.exitCode !== 0) {
+        if (getCommandExitCode(result) !== 0) {
             throw createSecurityCliFailure("store secret in macOS Keychain", result);
         }
     }
     async delete() {
         const result = await this.executeSecurityCommand(["delete-generic-password", "-s", this.service, "-a", this.account], "delete secret from macOS Keychain");
-        if (result.exitCode === 0 || isKeychainEntryNotFound(result)) {
+        if (getCommandExitCode(result) === 0 || isKeychainEntryNotFound(result)) {
             return;
         }
         throw createSecurityCliFailure("delete secret from macOS Keychain", result);
@@ -121,12 +121,27 @@ function stripTrailingLineBreak(value) {
     return value;
 }
 function isKeychainEntryNotFound(result) {
-    return result.exitCode === KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE;
+    return getCommandExitCode(result) === KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE;
 }
 function createSecurityCliFailure(operation, result) {
-    const details = result.stderr.trim() || result.stdout.trim();
+    const exitCode = getCommandExitCode(result);
+    const details = getCommandOutput(result, "stderr").trim()
+        || getCommandOutput(result, "stdout").trim();
     if (details) {
-        return new Error(`Failed to ${operation}: security exited with code ${result.exitCode}: ${details}`);
+        return new Error(`Failed to ${operation}: security exited with code ${exitCode}: ${details}`);
     }
-    return new Error(`Failed to ${operation}: security exited with code ${result.exitCode}`);
+    return new Error(`Failed to ${operation}: security exited with code ${exitCode}`);
+}
+function getCommandExitCode(result) {
+    const value = getOwnEntry(result, "exitCode");
+    return typeof value === "number" && Number.isInteger(value) ? value : 1;
+}
+function getCommandOutput(result, key) {
+    const value = getOwnEntry(result, key);
+    return typeof value === "string" ? value : "";
+}
+function getOwnEntry(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key)
+        ? record[key]
+        : undefined;
 }

package/node_modules/mcp-oauth/dist/client/auth-store-session-store.js

@@ -41,11 +41,13 @@ export function createAuthStoreClientStore(options) {
                 return null;
             }
             const parsed = JSON.parse(value);
-            if (typeof parsed === "object"
-                && parsed !== null
-                && !Array.isArray(parsed)
-                && typeof parsed.clientId === "string") {
-                return parsed;
+            const clientId = isObjectRecord(parsed) ? getOwnString(parsed, "clientId") : undefined;
+            if (clientId !== undefined) {
+                const client = { clientId };
+                if (isObjectRecord(parsed) && Object.prototype.hasOwnProperty.call(parsed, "clientSecret")) {
+                    client.clientSecret = getOwnEntry(parsed, "clientSecret");
+                }
+                return client;
             }
             throw new Error("Stored OAuth client must be a JSON object with clientId");
         },
@@ -98,3 +100,13 @@ function createIssuerSecretStore(issuer, options) {
         accountPrefix: "issuer",
     });
 }
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getOwnEntry(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}
+function getOwnString(record, key) {
+    const value = getOwnEntry(record, key);
+    return typeof value === "string" ? value : undefined;
+}

package/node_modules/mcp-oauth/dist/client/authorization-state.js

@@ -15,20 +15,33 @@ export function parseAuthorizationState(value) {
     try {
         const decoded = Buffer.from(value, "base64url").toString("utf8");
         const parsed = JSON.parse(decoded);
-        if (parsed.v !== 1
-            || typeof parsed.n !== "string"
-            || parsed.n.length === 0
-            || typeof parsed.i !== "string"
-            || parsed.i.length === 0
-            || typeof parsed.r !== "boolean") {
+        if (!isObjectRecord(parsed)) {
+            return null;
+        }
+        const version = getOwnEntry(parsed, "v");
+        const nonce = getOwnEntry(parsed, "n");
+        const issuer = getOwnEntry(parsed, "i");
+        const requireIssuer = getOwnEntry(parsed, "r");
+        if (version !== 1
+            || typeof nonce !== "string"
+            || nonce.length === 0
+            || typeof issuer !== "string"
+            || issuer.length === 0
+            || typeof requireIssuer !== "boolean") {
             return null;
         }
         return {
-            issuer: parsed.i,
-            requireIssuer: parsed.r,
+            issuer,
+            requireIssuer,
         };
     }
     catch {
         return null;
     }
 }
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getOwnEntry(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}