@fgv/ts-extras 5.0.2 → 5.1.0-0

package/dist/packlets/crypto-utils/keystore/model.js

@@ -0,0 +1,64 @@
+// Copyright (c) 2026 Erik Fortune
+//
+// 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.
+/**
+ * Current format version constant.
+ * @public
+ */
+export const KEYSTORE_FORMAT = 'keystore-v1';
+/**
+ * Default PBKDF2 iterations for key store encryption.
+ * Higher than regular files since this protects the master key vault.
+ * @public
+ */
+export const DEFAULT_KEYSTORE_ITERATIONS = 600000;
+/**
+ * Minimum salt length for key derivation.
+ * @public
+ */
+export const MIN_SALT_LENGTH = 16;
+/**
+ * All valid key store secret types.
+ * @public
+ */
+export const allKeyStoreSecretTypes = ['encryption-key', 'api-key'];
+/**
+ * Default PBKDF2 iterations for secret-level key derivation.
+ * Lower than keystore encryption since these are used more frequently.
+ * @public
+ */
+export const DEFAULT_SECRET_ITERATIONS = 350000;
+// ============================================================================
+// Detection Helper
+// ============================================================================
+/**
+ * Checks if a JSON object appears to be a key store file.
+ * Uses the format field as a discriminator.
+ * @param json - JSON object to check
+ * @returns true if the object has the key store format field
+ * @public
+ */
+export function isKeyStoreFile(json) {
+    if (typeof json !== 'object' || json === null) {
+        return false;
+    }
+    const obj = json;
+    return obj.format === KEYSTORE_FORMAT;
+}
+//# sourceMappingURL=model.js.map

package/dist/packlets/crypto-utils/model.js

@@ -0,0 +1,39 @@
+// Copyright (c) 2024 Erik Fortune
+//
+// 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.
+import * as Constants from './constants';
+export { Constants };
+// ============================================================================
+// Detection Helper
+// ============================================================================
+/**
+ * Checks if a JSON object appears to be an encrypted file.
+ * Uses the format field as a discriminator.
+ * @param json - JSON object to check
+ * @returns true if the object has the encrypted file format field
+ * @public
+ */
+export function isEncryptedFile(json) {
+    if (typeof json !== 'object' || json === null) {
+        return false;
+    }
+    const obj = json;
+    return obj.format === Constants.ENCRYPTED_FILE_FORMAT;
+}
+//# sourceMappingURL=model.js.map

package/dist/packlets/crypto-utils/nodeCryptoProvider.js

@@ -0,0 +1,159 @@
+// Copyright (c) 2024 Erik Fortune
+//
+// 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.
+import * as crypto from 'crypto';
+import { captureResult, fail, Failure, succeed, Success } from '@fgv/ts-utils';
+import * as Constants from './constants';
+/**
+ * Node.js implementation of {@link CryptoUtils.ICryptoProvider} using the built-in crypto module.
+ * Uses AES-256-GCM for authenticated encryption.
+ * @public
+ */
+export class NodeCryptoProvider {
+    /**
+     * Encrypts plaintext using AES-256-GCM.
+     * @param plaintext - UTF-8 string to encrypt
+     * @param key - 32-byte encryption key
+     * @returns `Success` with encryption result, or `Failure` with an error.
+     */
+    async encrypt(plaintext, key) {
+        return captureResult(() => {
+            if (key.length !== Constants.AES_256_KEY_SIZE) {
+                throw new Error(`Key must be ${Constants.AES_256_KEY_SIZE} bytes, got ${key.length}`);
+            }
+            // Generate random IV
+            const iv = crypto.randomBytes(Constants.GCM_IV_SIZE);
+            // Create cipher
+            const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+            // Encrypt
+            const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+            // Get auth tag
+            const authTag = cipher.getAuthTag();
+            return {
+                iv: new Uint8Array(iv),
+                authTag: new Uint8Array(authTag),
+                encryptedData: new Uint8Array(encrypted)
+            };
+        });
+    }
+    /**
+     * Decrypts ciphertext using AES-256-GCM.
+     * @param encryptedData - Encrypted bytes
+     * @param key - 32-byte decryption key
+     * @param iv - Initialization vector (12 bytes)
+     * @param authTag - GCM authentication tag (16 bytes)
+     * @returns `Success` with decrypted UTF-8 string, or `Failure` with an error.
+     */
+    async decrypt(encryptedData, key, iv, authTag) {
+        if (key.length !== Constants.AES_256_KEY_SIZE) {
+            return fail(`Key must be ${Constants.AES_256_KEY_SIZE} bytes, got ${key.length}`);
+        }
+        if (iv.length !== Constants.GCM_IV_SIZE) {
+            return fail(`IV must be ${Constants.GCM_IV_SIZE} bytes, got ${iv.length}`);
+        }
+        if (authTag.length !== Constants.GCM_AUTH_TAG_SIZE) {
+            return fail(`Auth tag must be ${Constants.GCM_AUTH_TAG_SIZE} bytes, got ${authTag.length}`);
+        }
+        return captureResult(() => {
+            // Create decipher
+            const decipher = crypto.createDecipheriv('aes-256-gcm', Buffer.from(key), Buffer.from(iv));
+            // Set auth tag
+            decipher.setAuthTag(Buffer.from(authTag));
+            // Decrypt
+            const decrypted = Buffer.concat([decipher.update(Buffer.from(encryptedData)), decipher.final()]);
+            return decrypted.toString('utf8');
+        }).withErrorFormat((e) => `Decryption failed: ${e}`);
+    }
+    /**
+     * Generates a random 32-byte key suitable for AES-256.
+     * @returns `Success` with generated key, or `Failure` with an error.
+     */
+    async generateKey() {
+        return captureResult(() => {
+            const key = crypto.randomBytes(Constants.AES_256_KEY_SIZE);
+            return new Uint8Array(key);
+        });
+    }
+    /**
+     * Derives a key from a password using PBKDF2.
+     * @param password - Password string
+     * @param salt - Salt bytes (should be at least 16 bytes)
+     * @param iterations - Number of iterations (recommend 100000+)
+     * @returns `Success` with derived 32-byte key, or `Failure` with an error.
+     */
+    async deriveKey(password, salt, iterations) {
+        if (iterations < 1) {
+            return fail('Iterations must be at least 1');
+        }
+        if (salt.length < 8) {
+            return fail('Salt should be at least 8 bytes');
+        }
+        return new Promise((resolve) => {
+            crypto.pbkdf2(password, Buffer.from(salt), iterations, Constants.AES_256_KEY_SIZE, 'sha256', (err, derivedKey) => {
+                /* c8 ignore next 3 - PBKDF2 internal errors are hard to trigger with valid parameters */
+                if (err) {
+                    resolve(fail(`Key derivation failed: ${err.message}`));
+                }
+                else {
+                    resolve(succeed(new Uint8Array(derivedKey)));
+                }
+            });
+        });
+    }
+    // ============================================================================
+    // Platform Utility Methods
+    // ============================================================================
+    /**
+     * Generates cryptographically secure random bytes.
+     * @param length - Number of bytes to generate
+     * @returns Success with random bytes, or Failure with error
+     */
+    generateRandomBytes(length) {
+        if (length < 1) {
+            return Failure.with('Length must be at least 1');
+        }
+        return captureResult(() => new Uint8Array(crypto.randomBytes(length)));
+    }
+    /**
+     * Encodes binary data to base64 string.
+     * @param data - Binary data to encode
+     * @returns Base64-encoded string
+     */
+    toBase64(data) {
+        return Buffer.from(data).toString('base64');
+    }
+    /**
+     * Decodes base64 string to binary data.
+     * @param base64 - Base64-encoded string
+     * @returns Success with decoded bytes, or Failure if invalid base64
+     */
+    fromBase64(base64) {
+        // Check for obviously invalid characters
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(base64)) {
+            return Failure.with('Invalid base64 string');
+        }
+        return Success.with(new Uint8Array(Buffer.from(base64, 'base64')));
+    }
+}
+/**
+ * Singleton instance of {@link CryptoUtils.NodeCryptoProvider}.
+ * @public
+ */
+export const nodeCryptoProvider = new NodeCryptoProvider();
+//# sourceMappingURL=nodeCryptoProvider.js.map

package/dist/packlets/experimental/formatter.js

@@ -41,7 +41,7 @@ export class FormattableBase {
         }
     }
     /**
-     * {@inheritdoc Experimental.Formattable.format}
+     * {@inheritDoc Experimental.Formattable.format}
      */
     format(template) {
         return captureResult(() => Mustache.render(template, this));

package/dist/packlets/mustache/index.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2020 Erik Fortune
+ *
+ * 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.
+ */
+export { MustacheTemplate } from './mustacheTemplate';
+//# sourceMappingURL=index.js.map

package/dist/packlets/mustache/interfaces.js

@@ -0,0 +1,25 @@
+/* c8 ignore start - Type definitions only, no runtime code */
+/*
+ * Copyright (c) 2020 Erik Fortune
+ *
+ * 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.
+ */
+export {};
+/* c8 ignore stop */
+//# sourceMappingURL=interfaces.js.map

package/dist/packlets/mustache/mustacheTemplate.js

@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2020 Erik Fortune
+ *
+ * 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.
+ */
+import { captureResult, fail, succeed } from '@fgv/ts-utils';
+import Mustache from 'mustache';
+/**
+ * Default options for MustacheTemplate
+ */
+const DEFAULT_OPTIONS = {
+    tags: ['{{', '}}'],
+    includeComments: false,
+    includePartials: false
+};
+/**
+ * A helper class for working with Mustache templates that provides
+ * validation, variable extraction, and context validation utilities.
+ * @public
+ */
+export class MustacheTemplate {
+    constructor(template, tokens, options) {
+        this.template = template;
+        this._tokens = tokens;
+        this.options = options;
+    }
+    /**
+     * Creates a new MustacheTemplate instance.
+     * @param template - The Mustache template string to parse
+     * @param options - Optional parsing options
+     * @returns Success with the template instance, or Failure if parsing fails
+     */
+    static create(template, options) {
+        const resolvedOptions = MustacheTemplate._resolveOptions(options);
+        return MustacheTemplate._parseTokens(template, resolvedOptions).onSuccess((tokens) => {
+            return succeed(new MustacheTemplate(template, tokens, resolvedOptions));
+        });
+    }
+    /**
+     * Validates that a template string has valid Mustache syntax.
+     * @param template - The template string to validate
+     * @param options - Optional parsing options
+     * @returns Success with true if valid, or Failure with a descriptive error message
+     */
+    static validate(template, options) {
+        const resolvedOptions = MustacheTemplate._resolveOptions(options);
+        return MustacheTemplate._parseTokens(template, resolvedOptions).onSuccess(() => succeed(true));
+    }
+    /**
+     * Checks if this template instance has valid syntax.
+     * Always returns Success(true) since parsing succeeded in create().
+     * @returns Success with true
+     */
+    validate() {
+        return succeed(true);
+    }
+    /**
+     * Extracts all variable references from the template.
+     * @returns An array of variable references found in the template
+     */
+    extractVariables() {
+        if (this._variables === undefined) {
+            this._variables = this._extractVariablesFromTokens(this._tokens);
+        }
+        return this._variables;
+    }
+    /**
+     * Extracts unique variable names from the template.
+     * @returns An array of unique variable name strings (e.g., ['user.name', 'items'])
+     */
+    extractVariableNames() {
+        const variables = this.extractVariables();
+        const seen = new Set();
+        const names = [];
+        for (const variable of variables) {
+            if (!seen.has(variable.name)) {
+                seen.add(variable.name);
+                names.push(variable.name);
+            }
+        }
+        return names;
+    }
+    /**
+     * Validates that a context object has all required variables.
+     * @param context - The context object to validate
+     * @returns Success with validation result containing details about present/missing variables
+     */
+    validateContext(context) {
+        const variables = this.extractVariables();
+        const presentVariables = [];
+        const missingVariables = [];
+        const missingDetails = [];
+        const checked = new Set();
+        for (const variable of variables) {
+            if (checked.has(variable.name)) {
+                continue;
+            }
+            checked.add(variable.name);
+            const lookup = this._lookupPath(context, variable.path);
+            if (lookup.found) {
+                presentVariables.push(variable.name);
+            }
+            else {
+                missingVariables.push(variable.name);
+                missingDetails.push({
+                    variable,
+                    failedAtSegment: lookup.failedAt,
+                    existingPath: lookup.existingPath
+                });
+            }
+        }
+        return succeed({
+            isValid: missingVariables.length === 0,
+            presentVariables,
+            missingVariables,
+            missingDetails
+        });
+    }
+    /**
+     * Renders the template with the given context.
+     * Use this for pre-validated contexts where you've already checked
+     * that all required variables are present.
+     * @param context - The context object for template rendering
+     * @returns Success with the rendered string, or Failure if rendering fails
+     */
+    render(context) {
+        return captureResult(() => Mustache.render(this.template, context));
+    }
+    /**
+     * Validates the context and renders the template if validation passes.
+     * @param context - The context object to validate and render with
+     * @returns Success with the rendered string, or Failure with validation or render errors
+     */
+    validateAndRender(context) {
+        return this.validateContext(context).onSuccess((validation) => {
+            if (!validation.isValid) {
+                const missing = validation.missingVariables.join(', ');
+                return fail(`Missing required variables: ${missing}`);
+            }
+            return this.render(context);
+        });
+    }
+    static _resolveOptions(options) {
+        var _a, _b;
+        if (options === undefined) {
+            return DEFAULT_OPTIONS;
+        }
+        return {
+            tags: options.tags ? [options.tags[0], options.tags[1]] : DEFAULT_OPTIONS.tags,
+            includeComments: (_a = options.includeComments) !== null && _a !== void 0 ? _a : DEFAULT_OPTIONS.includeComments,
+            includePartials: (_b = options.includePartials) !== null && _b !== void 0 ? _b : DEFAULT_OPTIONS.includePartials
+        };
+    }
+    static _parseTokens(template, options) {
+        return captureResult(() => Mustache.parse(template, options.tags));
+    }
+    _extractVariablesFromTokens(tokens) {
+        const variables = [];
+        for (const token of tokens) {
+            const type = token[0];
+            const value = token[1];
+            // Skip text tokens
+            if (type === 'text') {
+                continue;
+            }
+            // Handle comments based on options
+            if (type === '!' && !this.options.includeComments) {
+                continue;
+            }
+            // Handle partials based on options
+            if (type === '>' && !this.options.includePartials) {
+                continue;
+            }
+            // Handle variable tokens: 'name', '&', '#', '^', and optionally '!', '>'
+            if (type === 'name' || type === '&' || type === '#' || type === '^' || type === '!' || type === '>') {
+                const isSection = type === '#' || type === '^';
+                variables.push({
+                    name: value,
+                    path: this._parsePath(value),
+                    tokenType: type,
+                    isSection
+                });
+            }
+            // Recursively extract from nested tokens in sections
+            if ((type === '#' || type === '^') && token.length > 4) {
+                const nestedTokens = token[4];
+                if (nestedTokens) {
+                    variables.push(...this._extractVariablesFromTokens(nestedTokens));
+                }
+            }
+        }
+        return variables;
+    }
+    _parsePath(name) {
+        // Handle special case of '.' which means current context
+        if (name === '.') {
+            return ['.'];
+        }
+        // Split on dots to get path segments
+        return name.split('.').filter((segment) => segment.length > 0);
+    }
+    _lookupPath(context, path) {
+        // Handle '.' which always exists if context is not null/undefined
+        if (path.length === 1 && path[0] === '.') {
+            return { found: context !== undefined && context !== null, existingPath: [] };
+        }
+        let current = context;
+        const existingPath = [];
+        for (const segment of path) {
+            if (current === undefined || current === null) {
+                return { found: false, existingPath, failedAt: segment };
+            }
+            if (typeof current !== 'object') {
+                return { found: false, existingPath, failedAt: segment };
+            }
+            const obj = current;
+            if (!(segment in obj)) {
+                return { found: false, existingPath, failedAt: segment };
+            }
+            current = obj[segment];
+            existingPath.push(segment);
+        }
+        return { found: true, existingPath };
+    }
+}
+//# sourceMappingURL=mustacheTemplate.js.map

package/dist/packlets/record-jar/recordJarHelpers.js

@@ -150,7 +150,7 @@ class RecordParser {
         var _a, _b;
         let trimmed = line.trim();
         if (!this._body.isContinuation) {
-            /* c8 ignore next */
+            /* c8 ignore next - functional code tested but coverage intermittently missed */
             const fixedSize = (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.fixedContinuationSize) !== null && _b !== void 0 ? _b : 0;
             if (fixedSize > 0) {
                 if (trimmed.length < line.length - fixedSize) {

package/dist/packlets/yaml/converters.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2024 Erik Fortune
+ *
+ * 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.
+ */
+import { Conversion, captureResult, fail } from '@fgv/ts-utils';
+import * as yaml from 'js-yaml';
+/**
+ * Creates a converter that parses YAML string content and then applies the supplied converter.
+ * @param converter - Converter to apply to the parsed YAML
+ * @returns Converter that parses YAML then validates
+ * @public
+ */
+export function yamlConverter(converter) {
+    return new Conversion.BaseConverter((from) => {
+        if (typeof from !== 'string') {
+            return fail('Input must be a string');
+        }
+        const parseResult = captureResult(() => yaml.load(from));
+        if (parseResult.isFailure()) {
+            return fail(`Failed to parse YAML: ${parseResult.message}`);
+        }
+        const parsed = parseResult.value;
+        if (typeof parsed !== 'object' || parsed === null) {
+            return fail('Failed to parse YAML: YAML content must be an object');
+        }
+        return converter.convert(parsed);
+    });
+}
+//# sourceMappingURL=converters.js.map

package/dist/packlets/yaml/index.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2024 Erik Fortune
+ *
+ * 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.
+ */
+export * from './converters';
+//# sourceMappingURL=index.js.map

package/dist/packlets/zip-file-tree/index.js

@@ -29,4 +29,5 @@
  * @packageDocumentation
  */
 export { ZipFileTreeAccessors, ZipFileItem, ZipDirectoryItem } from './zipFileTreeAccessors';
+export * from './zipFileTreeWriter';
 //# sourceMappingURL=index.js.map