@fgv/ts-res 5.0.1-9 → 5.0.2-0

package/dist/packlets/runtime/resourceTreeResolver.js

@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2025 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 { MessageAggregator, succeed, fail, captureResult } from '@fgv/ts-utils';
+import { Converters as JsonConverters } from '@fgv/ts-json-base';
+/**
+ * Specialized resolver for resource tree operations, providing enhanced APIs for
+ * resolving entire resource trees from either resource IDs or pre-built tree nodes.
+ *
+ * This class provides a clean separation between individual resource resolution
+ * (handled by ResourceResolver) and tree-based operations, with support for
+ * lazy tree construction and enhanced error handling.
+ *
+ * @public
+ */
+export class ResourceTreeResolver {
+    /**
+     * Creates a {@link Runtime.ResourceTreeResolver | ResourceTreeResolver} instance.
+     * @param resolver - The ResourceResolver to use for individual resource resolution
+     */
+    constructor(resolver) {
+        this.resolver = resolver;
+        this._resourceManager = resolver.resourceManager;
+    }
+    /**
+     * Creates a {@link Runtime.ResourceTreeResolver | ResourceTreeResolver} instance.
+     * @param resolver - The ResourceResolver to use for individual resource resolution
+     */
+    static create(resolver) {
+        return captureResult(() => new ResourceTreeResolver(resolver));
+    }
+    /**
+     * Gets the built resource tree, building it lazily on first access.
+     * @returns The resource tree root
+     * @throws Error if no resource manager was provided or tree building fails
+     * @public
+     */
+    get tree() {
+        return this._getTree().orThrow();
+    }
+    /**
+     * Implementation for both overloads.
+     */
+    resolveComposedResourceTree(idOrNode, options) {
+        if (typeof idOrNode === 'string') {
+            return this._resolveFromResourceId(idOrNode, options);
+        }
+        return this._resolveFromTreeNode(idOrNode, options);
+    }
+    _getTree() {
+        if (!this._tree) {
+            this._tree = this._resourceManager.getBuiltResourceTree();
+        }
+        return this._tree;
+    }
+    /**
+     * Resolves a tree from a resource ID by first building the tree from the resource manager.
+     * @internal
+     */
+    _resolveFromResourceId(resourceId, options) {
+        return this._getTree().onSuccess((tree) => {
+            return tree.children.validating
+                .getById(resourceId)
+                .onFailure((message) => fail(`${resourceId}: Resource not found in resource tree: ${message}`))
+                .onSuccess((rootNode) => this._resolveFromTreeNode(rootNode, options));
+        });
+    }
+    /**
+     * Resolves a pre-built tree node using the extracted tree resolution logic.
+     * @internal
+     */
+    _resolveFromTreeNode(node, options) {
+        var _a, _b;
+        const resourceErrorMode = (_a = options === null || options === void 0 ? void 0 : options.onResourceError) !== null && _a !== void 0 ? _a : 'fail';
+        const emptyBranchMode = (_b = options === null || options === void 0 ? void 0 : options.onEmptyBranch) !== null && _b !== void 0 ? _b : 'allow';
+        // Handle root node with proper Result chaining
+        return node.isLeaf
+            ? this._processLeafNode(node, '', resourceErrorMode).onSuccess((value) => value !== undefined ? JsonConverters.jsonObject.convert(value) : succeed(undefined))
+            : this._processBranchNode(node, '', {
+                onResourceError: resourceErrorMode,
+                onEmptyBranch: emptyBranchMode
+            }).onSuccess((value) => {
+                // Only convert undefined to {} if emptyBranchMode is 'allow'
+                // For 'omit' mode or custom handlers returning undefined, preserve undefined
+                /* c8 ignore next 3 - defense in depth */
+                return succeed(value === undefined && emptyBranchMode === 'allow' ? {} : value);
+            });
+    }
+    /**
+     * Handles resource resolution errors according to the specified mode.
+     * @param resource - The resource that failed to resolve
+     * @param message - The error message from the failed resolution
+     * @param mode - The error handling mode
+     * @param path - The path to the resource in the tree (for error context)
+     * @internal
+     */
+    _handleResourceError(resource, message, mode, path) {
+        if (mode === 'ignore') {
+            return succeed(undefined);
+        }
+        if (mode === 'fail') {
+            const errorMessage = path ? `${path}: ${message}` : message;
+            return fail(errorMessage);
+        }
+        // Custom handler - pass the resolver for recovery attempts
+        return mode(resource, message, this.resolver);
+    }
+    /**
+     * Handles empty branch nodes according to the specified mode.
+     * @param node - The empty branch node
+     * @param failedChildren - Names of children that failed to resolve
+     * @param mode - The empty branch handling mode
+     * @param path - The path to the branch in the tree (for error context)
+     * @internal
+     */
+    _handleEmptyBranch(node, failedChildren, mode, path) {
+        if (mode === 'omit') {
+            return succeed(undefined);
+        }
+        if (mode === 'allow') {
+            return succeed({});
+        }
+        // Custom handler - pass the resolver for recovery attempts
+        return mode(node, failedChildren, this.resolver);
+    }
+    /**
+     * Processes a leaf node by resolving its resource value.
+     * @param node - The leaf node to process (must be a leaf node)
+     * @param path - The path to the node in the tree
+     * @param resourceErrorMode - How to handle resource resolution errors
+     * @internal
+     */
+    _processLeafNode(node, path, resourceErrorMode) {
+        /* c8 ignore next 3 - defense in depth */
+        if (!node.isLeaf) {
+            return fail(`Internal error: processLeafNode called on non-leaf node at ${path}`);
+        }
+        return this.resolver
+            .resolveComposedResourceValue(node.resource)
+            .onSuccess((value) => succeed(value))
+            .onFailure((message) => this._handleResourceError(node.resource, message, resourceErrorMode, path));
+    }
+    /**
+     * Processes a branch node by recursively resolving all its children.
+     * @param node - The branch node to process (must be a branch node)
+     * @param path - The path to the node in the tree
+     * @param options - Resolution options
+     * @internal
+     */
+    _processBranchNode(node, path, options) {
+        var _a, _b;
+        /* c8 ignore next 3 - defense in depth */
+        if (node.isLeaf) {
+            return fail(`Internal error: processBranchNode called on leaf node at ${path}`);
+        }
+        /* c8 ignore next 2 - ?? is defense in depth */
+        const resourceErrorMode = (_a = options.onResourceError) !== null && _a !== void 0 ? _a : 'fail';
+        const emptyBranchMode = (_b = options.onEmptyBranch) !== null && _b !== void 0 ? _b : 'allow';
+        const aggregator = new MessageAggregator();
+        // Process all children
+        const childResults = {};
+        const failedChildren = [];
+        for (const [childName, childNode] of node.children) {
+            const childPath = path ? `${path}.${childName}` : childName;
+            const childResult = childNode.isLeaf
+                ? this._processLeafNode(childNode, childPath, resourceErrorMode)
+                : this._processBranchNode(childNode, childPath, options);
+            // Process the child result and update our state
+            if (childResult.isSuccess()) {
+                const value = childResult.value;
+                if (value !== undefined) {
+                    childResults[childName] = value;
+                }
+                else {
+                    failedChildren.push(childName);
+                }
+            }
+            else {
+                if (resourceErrorMode === 'fail') {
+                    aggregator.addMessage(childResult.message);
+                }
+                failedChildren.push(childName);
+            }
+        }
+        // Check for accumulated errors in 'fail' mode
+        if (resourceErrorMode === 'fail' && aggregator.hasMessages) {
+            return fail(aggregator.toString('; '));
+        }
+        // Handle empty branch
+        if (Object.keys(childResults).length === 0) {
+            return this._handleEmptyBranch(node, failedChildren, emptyBranchMode, path).onSuccess((value) => {
+                if (value === undefined) {
+                    return succeed(undefined);
+                }
+                // Ensure we return JsonObject or undefined
+                return JsonConverters.jsonObject.convert(value);
+            });
+        }
+        return succeed(childResults);
+    }
+}
+//# sourceMappingURL=resourceTreeResolver.js.map

package/dist/packlets/runtime/validate.js

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2025 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 { Validators } from '@fgv/ts-utils';
+import { Validators as JsonValidators } from '@fgv/ts-json-base';
+import { Validate } from '../common';
+import { ResourceType } from '../resource-types';
+import { ConcreteDecision } from '../decisions';
+/**
+ * Validates an {@link Runtime.IResourceCandidate | IResourceCandidate} object.
+ * @public
+ */
+export const resourceCandidate = Validators.object({
+    json: JsonValidators.jsonObject,
+    isPartial: Validators.boolean,
+    mergeMethod: Validators.isA('resource value merge method', (v) => v === 'augment' || v === 'delete' || v === 'replace')
+});
+/**
+ * Validates an {@link Runtime.IResource | IResource} object.
+ * @public
+ */
+export const resource = Validators.object({
+    id: Validators.isA('ResourceId', (v) => typeof v === 'string' && Validate.isValidResourceId(v)),
+    name: Validators.isA('ResourceName', (v) => typeof v === 'string' && Validate.isValidResourceName(v)),
+    resourceType: Validators.isA('ResourceType instance', (v) => v instanceof ResourceType),
+    decision: Validators.isA('ConcreteDecision instance', (v) => v instanceof ConcreteDecision),
+    candidates: Validators.arrayOf(resourceCandidate)
+});
+//# sourceMappingURL=validate.js.map

package/dist/packlets/zip-archive/convert.js

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2025 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 { Validators, Converters } from '@fgv/ts-utils';
+import { Convert as ConfigConvert } from '../config';
+/**
+ * Validator for ZIP archive input type
+ * @public
+ */
+export const zipArchiveInputType = Validators.enumeratedValue([
+    'file',
+    'directory'
+]);
+/**
+ * Validator for ZIP archive config type
+ * @public
+ */
+export const zipArchiveConfigType = Validators.enumeratedValue(['file']);
+/**
+ * Validator for ZIP archive input information
+ * @public
+ */
+export const zipArchiveInputInfo = Validators.object({
+    type: zipArchiveInputType,
+    originalPath: Validators.string,
+    archivePath: Validators.string
+});
+/**
+ * Validator for ZIP archive config information
+ * @public
+ */
+export const zipArchiveConfigInfo = Validators.object({
+    type: zipArchiveConfigType,
+    originalPath: Validators.string,
+    archivePath: Validators.string
+});
+/**
+ * Validator for ZIP archive manifest
+ * Compatible with existing tools from ts-res-browser-cli
+ * @public
+ */
+export const zipArchiveManifest = Validators.object({
+    timestamp: Validators.string,
+    input: zipArchiveInputInfo.optional(),
+    config: zipArchiveConfigInfo.optional()
+});
+/**
+ * Validator for MIME type strings
+ * @public
+ */
+export const mimeType = Validators.string;
+/**
+ * Converter for imported file
+ * @public
+ */
+export const importedFile = Converters.strictObject({
+    name: Converters.string,
+    path: Converters.string,
+    content: Converters.string,
+    type: Converters.string // MIME type as string
+});
+/**
+ * Converter for imported directory structure (recursive)
+ * Note: Uses Converter pattern because Validators don't support recursion with self parameter
+ * @public
+ */
+export const importedDirectory = Converters.generic((from, self, context) => {
+    return Converters.strictObject({
+        name: Converters.string,
+        files: Converters.arrayOf(importedFile),
+        subdirectories: Converters.arrayOf(self)
+    }).convert(from, context);
+});
+/**
+ * Validator for system configuration (delegates to config packlet)
+ * This validates that the parsed JSON conforms to the system configuration schema
+ * @public
+ */
+export const systemConfiguration = Validators.isA('system configuration', (value) => {
+    return ConfigConvert.systemConfiguration.convert(value).isSuccess();
+});
+//# sourceMappingURL=convert.js.map

package/dist/packlets/zip-archive/index.browser.js

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+/**
+ * Browser-safe ZIP archive functionality for ts-res source file archives
+ *
+ * This packlet provides consolidated ZIP archive creation and loading functionality
+ * for source files, compatible with browsers using fflate.
+ *
+ * @remarks
+ * ZIP archives contain source files for resource ingestion with directory
+ * structure preserved and optional validation but no processing or transformation.
+ * This is distinct from ZIP bundles which contain processed resource output.
+ *
+ * ZipArchiveCreator supports browser usage when FileTreeItems are provided directly.
+ * Methods accepting file paths require Node.js fs access and should not be called in browser.
+ *
+ * ZipArchiveLoader is fully browser-compatible and works with File API or ArrayBuffer.
+ *
+ * @packageDocumentation
+ */
+import * as Json from './json';
+import * as Convert from './convert';
+// Namespaces
+export { Json, Convert };
+// Core classes (browser-compatible when used with FileTreeItems or buffers)
+export { ZipArchiveCreator } from './zipArchiveCreator';
+export { ZipArchiveLoader } from './zipArchiveLoader';
+// Format utilities
+export { createZipArchiveManifest, parseZipArchiveManifest, validateZipArchiveManifest, parseZipArchiveConfiguration, generateZipArchiveFilename, normalizePath, getDirectoryName, sanitizeFilename, isZipFile } from './zipArchiveFormat';
+// Constants
+export { ZipArchiveConstants } from './types';
+// Note: ZipArchiveCreator._getInputFileTreeItem() and _getConfigFileTreeItem()
+// use FileTree.forFilesystem() internally when given file paths.
+// In browser, provide FileTreeItems directly via IZipArchiveFileTreeOptions.
+//# sourceMappingURL=index.browser.js.map

package/dist/packlets/zip-archive/index.js

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+/**
+ * ZIP archive functionality for ts-res source file archives
+ *
+ * This packlet provides consolidated ZIP archive creation and loading functionality
+ * for source files, compatible with existing tools while using fflate for
+ * universal browser compatibility.
+ *
+ * @remarks
+ * ZIP archives contain source files for resource ingestion with directory
+ * structure preserved and optional validation but no processing or transformation.
+ * This is distinct from ZIP bundles which contain processed resource output.
+ *
+ * @packageDocumentation
+ */
+import * as Json from './json';
+import * as Convert from './convert';
+// Namespaces
+export { Json, Convert };
+// Core classes
+export { ZipArchiveCreator } from './zipArchiveCreator';
+export { ZipArchiveLoader } from './zipArchiveLoader';
+// Format utilities
+export { createZipArchiveManifest, parseZipArchiveManifest, validateZipArchiveManifest, parseZipArchiveConfiguration, generateZipArchiveFilename, normalizePath, getDirectoryName, sanitizeFilename, isZipFile } from './zipArchiveFormat';
+// Constants
+export { ZipArchiveConstants } from './types';
+//# sourceMappingURL=index.js.map

package/dist/packlets/zip-archive/json.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025 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 {};
+//# sourceMappingURL=json.js.map

package/dist/packlets/zip-archive/types.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2025 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.
+ */
+/**
+ * Constants for ZIP archive structure
+ * @public
+ */
+export const ZipArchiveConstants = {
+    /** Manifest file name */
+    MANIFEST_FILE: 'manifest.json',
+    /** Configuration file name */
+    CONFIG_FILE: 'config.json',
+    /** Input files directory */
+    INPUT_DIR: 'input',
+    /** Configuration files directory */
+    CONFIG_DIR: 'config'
+};
+//# sourceMappingURL=types.js.map