@fgv/ts-extras 5.0.1-9 → 5.0.1

package/dist/packlets/experimental/rangeOf.js

@@ -0,0 +1,178 @@
+/*
+ * 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 } from '@fgv/ts-utils';
+import Mustache from 'mustache';
+/**
+ * Default {@link Experimental.RangeOfFormats | formats} to use for both
+ * open-ended and complete {@link Experimental.RangeOf | RangeOf<T>}.
+ * @public
+ */
+export const DEFAULT_RANGEOF_FORMATS = {
+    minOnly: '{{min}}-',
+    maxOnly: '-{{max}}',
+    minMax: '{{min}}-{{max}}'
+};
+/**
+ * Simple implementation of a possibly open-ended range of some comparable
+ * type `<T>` with test and formatting.
+ * @public
+ */
+export class RangeOf {
+    /**
+     * Creates a new {@link Experimental.RangeOf | RangeOf<T>}.
+     * @param min - Optional minimum extent of the range.
+     * @param max - Optional maximum extent of the range.
+     */
+    constructor(min, max) {
+        if (min !== undefined && max !== undefined && this._compare(min, max) === 'greater') {
+            throw new Error(`Inverted range - ${JSON.stringify(min)} must be <= ${JSON.stringify(max)}.`);
+        }
+        this.min = min;
+        this.max = max;
+    }
+    /**
+     * Static constructor for a {@link Experimental.RangeOf | RangeOf<T>}.
+     * @param init - {@link Experimental.RangeOfProperties | Range initializer}.
+     * @returns A new {@link Experimental.RangeOf | RangeOf<T>}.
+     */
+    static createRange(init) {
+        return captureResult(() => new RangeOf(init === null || init === void 0 ? void 0 : init.min, init === null || init === void 0 ? void 0 : init.max));
+    }
+    /**
+     * Gets a formatted description of a {@link Experimental.RangeOfProperties | RangeOfProperties<T>} given an
+     * optional set of formats and 'empty' value to use.
+     * @param range - The {@link Experimental.RangeOfProperties | RangeOfProperties<T>} to be formatted.
+     * @param formats - Optional {@link Experimental.RangeOfFormats | formats} to use. Default is
+     * {@link Experimental.DEFAULT_RANGEOF_FORMATS | DEFAULT_RANGEOF_FORMATS}.
+     * @param emptyValue - Value which represents unbounded minimum or maximum for this range. Default is `undefined`.
+     * @returns A string representation of the range.
+     */
+    static propertiesToString(range, formats, emptyValue) {
+        formats = formats !== null && formats !== void 0 ? formats : DEFAULT_RANGEOF_FORMATS;
+        if (range.min !== undefined && range.min !== emptyValue) {
+            if (range.max !== undefined && range.max !== emptyValue) {
+                return Mustache.render(formats.minMax, range);
+            }
+            else {
+                return Mustache.render(formats.minOnly, range);
+            }
+        }
+        else if (range.max !== undefined && range.max !== emptyValue) {
+            return Mustache.render(formats.maxOnly, range);
+        }
+        return undefined;
+    }
+    /**
+     * Default comparison uses javascript built-in comparison.
+     * @param t1 - First value to be compared.
+     * @param t2 - Second value to be compared.
+     * @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
+     * and `'equal'` if `t1` and `t2` are equal.
+     * @internal
+     */
+    static _defaultCompare(t1, t2) {
+        if (t1 < t2) {
+            return 'less';
+        }
+        else if (t1 > t2) {
+            return 'greater';
+        }
+        return 'equal';
+    }
+    /**
+     * Checks if a supplied value is within this range.
+     * @param t - The value to be tested.
+     * @returns `'included'` if `t` falls within the range, `'less'` if `t` falls
+     * below the minimum extent of the range and `'greater'` if `t` is above the
+     * maximum extent.
+     */
+    check(t) {
+        if (this.min !== undefined && this._compare(t, this.min) === 'less') {
+            return 'less';
+        }
+        if (this.max !== undefined && this._compare(t, this.max) !== 'less') {
+            return 'greater';
+        }
+        return 'included';
+    }
+    /**
+     * Determines if a supplied value is within this range.
+     * @param t - The value to be tested.
+     * @returns Returns `true` if `t` falls within the range, `false` otherwise.
+     */
+    includes(t) {
+        return this.check(t) === 'included';
+    }
+    /**
+     * Finds the transition value that would bring a supplied value `t` into
+     * range.
+     * @param t - The value to be tested.
+     * @returns The minimum extent of the range if `t` is below the range or
+     * the maximum extent of the range if `t` is above the range.  Returns
+     * `undefined` if `t` already falls within the range.
+     */
+    findTransition(t) {
+        switch (this.check(t)) {
+            case 'less':
+                return this.min;
+            case 'included':
+                return this.max;
+        }
+        return undefined;
+    }
+    /**
+     * Formats the minimum and maximum values of this range.
+     * @param format - A format function used to format the values.
+     * @returns A {@link Experimental.RangeOfProperties | RangeOfProperties<string>} containing the
+     * formatted representation of the {@link Experimental.RangeOf.min | minimum} and
+     * {@link Experimental.RangeOf.max | maximum}
+     * extent of the range, or `undefined` for an extent that is not present.
+     */
+    toFormattedProperties(format) {
+        return {
+            min: this.min !== undefined ? format(this.min) : undefined,
+            max: this.max !== undefined ? format(this.max) : undefined
+        };
+    }
+    /**
+     * Formats this range using the supplied format function.
+     * @param format - Format function used to format minimum and maximum extent values.
+     * @param formats - The {@link Experimental.RangeOfFormats | format strings} used to format the range
+     * (default {@link Experimental.DEFAULT_RANGEOF_FORMATS}).
+     * @returns Returns a formatted representation of this range.
+     */
+    format(format, formats) {
+        return RangeOf.propertiesToString(this.toFormattedProperties(format), formats);
+    }
+    /**
+     * Inner compare method can be overridden by a derived class.
+     * @param t1 - First value to compare.
+     * @param t2 - Second value to compare.
+     * @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
+     * and `'equal'` if `t1` and `t2` are equal.
+     * @internal
+     */
+    _compare(t1, t2) {
+        return RangeOf._defaultCompare(t1, t2);
+    }
+}
+//# sourceMappingURL=rangeOf.js.map

package/dist/packlets/hash/index.browser.js

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+// Browser-safe hash exports - excludes Node.js crypto dependencies
+export * from './md5Normalizer.browser';
+//# sourceMappingURL=index.browser.js.map

package/dist/packlets/hash/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 * from './md5Normalizer';
+//# sourceMappingURL=index.js.map

package/dist/packlets/hash/index.node.js

@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+/* c8 ignore start - Node.js-specific export used conditionally in package.json */
+// Node.js hash exports - includes crypto-based implementations
+export * from './md5Normalizer';
+/* c8 ignore stop */
+//# sourceMappingURL=index.node.js.map

package/dist/packlets/hash/md5Normalizer.browser.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2023 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 { Hash } from '@fgv/ts-utils';
+/**
+ * Browser-compatible MD5 normalizer that uses CRC32 hashing for cross-platform compatibility.
+ * This provides the same interface as the Node.js MD5 version but uses CRC32 algorithm
+ * which works consistently across both Node.js and browser environments.
+ *
+ * Note: While this is named Md5Normalizer for API compatibility, it actually uses CRC32
+ * hashing to ensure cross-platform compatibility between Node.js and browser environments.
+ * @public
+ */
+export class Md5Normalizer extends Hash.Crc32Normalizer {
+}
+//# sourceMappingURL=md5Normalizer.browser.js.map

package/dist/packlets/hash/md5Normalizer.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 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 { Hash } from '@fgv/ts-utils';
+import * as crypto from 'crypto';
+/**
+ * A hashing normalizer which computes object
+ * hash using the MD5 algorithm.
+ * @public
+ */
+export class Md5Normalizer extends Hash.HashingNormalizer {
+    constructor() {
+        super(Md5Normalizer.md5Hash);
+    }
+    static md5Hash(parts) {
+        return crypto.createHash('md5').update(parts.join('|'), 'utf8').digest('hex');
+    }
+}
+//# sourceMappingURL=md5Normalizer.js.map

package/dist/packlets/record-jar/index.browser.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 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 RecordJar exports - excludes Node.js filesystem dependencies
+// Export all browser-safe parsing functionality
+export * from './recordJarHelpers';
+// Export FileTree-based reading (web-compatible)
+export { readRecordJarFromTree } from './recordJarFileHelpers';
+// Exclude:
+// - readRecordJarFileSync (requires Node.js fs/path)
+//# sourceMappingURL=index.browser.js.map

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 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 tree-shakeable functions
+export * from './recordJarHelpers';
+// Filesystem helpers in separate module for tree-shaking
+export * from './recordJarFileHelpers';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2022 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 fs from 'fs';
+import * as path from 'path';
+import { captureResult } from '@fgv/ts-utils';
+import { parseRecordJarLines } from './recordJarHelpers';
+/**
+ * Reads a record-jar file from a supplied path.
+ * @param srcPath - Source path from which the file is read.
+ * @param options - Optional parser configuration
+ * @returns The contents of the file as an array of `Record<string, string>`
+ * @see https://datatracker.ietf.org/doc/html/draft-phillips-record-jar-01
+ * @public
+ */
+export function readRecordJarFileSync(srcPath, options) {
+    return captureResult(() => {
+        const fullPath = path.resolve(srcPath);
+        return fs.readFileSync(fullPath, 'utf8').toString().split(/\r?\n/);
+    }).onSuccess((lines) => {
+        return parseRecordJarLines(lines, options);
+    });
+}
+/**
+ * Reads a record-jar file from a FileTree.
+ * @param fileTree - The FileTree to read from.
+ * @param filePath - Path of the file within the tree.
+ * @param options - Optional parser configuration
+ * @returns The contents of the file as an array of `Record<string, string>`
+ * @see https://datatracker.ietf.org/doc/html/draft-phillips-record-jar-01
+ * @public
+ */
+export function readRecordJarFromTree(fileTree, filePath, options) {
+    return fileTree
+        .getFile(filePath)
+        .onSuccess((file) => file.getRawContents())
+        .onSuccess((contents) => {
+        const lines = contents.split(/\r?\n/);
+        return parseRecordJarLines(lines, options);
+    });
+}
+//# sourceMappingURL=recordJarFileHelpers.js.map

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

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2022 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 { fail, isKeyOf, succeed } from '@fgv/ts-utils';
+class RecordParser {
+    constructor(options) {
+        this.records = [];
+        this._fields = {};
+        this._name = undefined;
+        this._body = undefined;
+        this.options = options !== null && options !== void 0 ? options : {};
+    }
+    static parse(lines, options) {
+        return new RecordParser(options)._parse(lines);
+    }
+    static _parseRecordBody(body) {
+        const isContinuation = body.endsWith('\\');
+        if (isContinuation) {
+            body = body.slice(0, body.length - 1);
+        }
+        if (this._hasEscapes(body)) {
+            const result = this._replaceEscapes(body);
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+            body = result.value;
+        }
+        return succeed({ body, isContinuation });
+    }
+    static _hasEscapes(from) {
+        return from.includes('\\') || from.includes('&');
+    }
+    static _replaceEscapes(body) {
+        const invalid = [];
+        const escaped = body.replace(/(\\.)|(&#x[a-fA-F0-9]{2,6};)/g, (match) => {
+            switch (match) {
+                case '\\\\':
+                    return '\\';
+                case '\\&':
+                    return '&';
+                case '\\r':
+                    return '\r';
+                case '\\n':
+                    return '\n';
+                case '\\t':
+                    return '\t';
+            }
+            if (match.startsWith('&')) {
+                const hexCode = `0x${match.slice(3, match.length - 1)}`;
+                const charCode = Number.parseInt(hexCode, 16);
+                return String.fromCharCode(charCode);
+            }
+            invalid.push(match);
+            return '\\';
+        });
+        if (invalid.length > 0) {
+            return fail(`unrecognized escape "${invalid.join(', ')}" in record-jar body`);
+        }
+        return succeed(escaped);
+    }
+    static _applyOptions(record, options) {
+        if (options.arrayFields) {
+            record = Object.assign({}, record); // don't edit incoming values
+            const arrayFields = Array.isArray(options.arrayFields)
+                ? options.arrayFields
+                : options.arrayFields(record);
+            for (const field of arrayFields) {
+                if (isKeyOf(field, record) && typeof record[field] === 'string') {
+                    const current = record[field];
+                    record[field] = [current];
+                }
+            }
+        }
+        return record;
+    }
+    _parse(lines) {
+        var _a, _b;
+        for (let n = 0; n < lines.length; n++) {
+            const line = lines[n];
+            if (line.startsWith('%%') && !((_a = this._body) === null || _a === void 0 ? void 0 : _a.isContinuation)) {
+                const result = this._writePendingRecord();
+                if (result.isFailure()) {
+                    return fail(`${n}: ${result.message}`);
+                }
+            }
+            else if (/^\s*$/.test(line)) {
+                // ignore blank lines but cancel continuation
+                if (this._body) {
+                    this._body.isContinuation = false;
+                }
+                continue;
+            }
+            else if (((_b = this._body) === null || _b === void 0 ? void 0 : _b.isContinuation) || /^\s+/.test(line)) {
+                // explicit continuation on previous line or implicit starts with whitespace
+                if (this._body === undefined) {
+                    return fail(`${n}: continuation ("${line}") without prior value.`);
+                }
+                const result = this._parseContinuation(line);
+                if (result.isFailure()) {
+                    return fail(`${n}: ${result.message}`);
+                }
+                this._body = result.value;
+            }
+            else {
+                const result = this._parseField(line);
+                if (result.isFailure()) {
+                    return fail(`${n}: ${result.message}`);
+                }
+            }
+        }
+        const result = this._writePendingRecord();
+        if (result.isFailure()) {
+            return fail(`${lines.length}: ${result.message}`);
+        }
+        return succeed(this.records);
+    }
+    _parseField(line) {
+        const separatorIndex = line.indexOf(':');
+        if (separatorIndex < 1) {
+            return fail(`malformed line ("${line}") in record-jar.`);
+        }
+        const parts = [line.slice(0, separatorIndex), line.slice(separatorIndex + 1)];
+        return this._writePendingField().onSuccess(() => {
+            this._name = parts[0].trimEnd();
+            return RecordParser._parseRecordBody(parts[1].trim()).onSuccess((body) => {
+                this._body = body;
+                return succeed(true);
+            });
+        });
+    }
+    _parseContinuation(line) {
+        var _a, _b;
+        let trimmed = line.trim();
+        if (!this._body.isContinuation) {
+            /* c8 ignore next */
+            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) {
+                    // oops, took too much
+                    trimmed = line.slice(fixedSize);
+                }
+            }
+        }
+        return RecordParser._parseRecordBody(trimmed).onSuccess((newBody) => {
+            return succeed({
+                body: `${this._body.body}${newBody.body}`,
+                isContinuation: newBody.isContinuation
+            });
+        });
+    }
+    _havePendingRecord() {
+        return Object.keys(this._fields).length > 0;
+    }
+    _writePendingRecord() {
+        return this._writePendingField().onSuccess(() => {
+            let record = this._havePendingRecord() ? this._fields : undefined;
+            if (record !== undefined) {
+                record = RecordParser._applyOptions(record, this.options);
+                this.records.push(record);
+                this._fields = {};
+            }
+            return succeed(undefined);
+        });
+    }
+    _writePendingField() {
+        if (this._name !== undefined) {
+            if (this._body.body.length < 1) {
+                return fail('empty body value not allowed');
+            }
+            if (!isKeyOf(this._name, this._fields)) {
+                this._fields[this._name] = this._body.body;
+            }
+            else if (typeof this._fields[this._name] === 'string') {
+                const current = this._fields[this._name];
+                this._fields[this._name] = [current, this._body.body];
+            }
+            else {
+                const current = this._fields[this._name];
+                current.push(this._body.body);
+            }
+            this._name = undefined;
+            this._body = undefined;
+        }
+        return succeed(true);
+    }
+}
+/**
+ * Reads a record-jar from an array of strings, each of which represents one
+ * line in the source file.
+ * @param lines - the array of strings to be parsed
+ * @param options - Optional parser configuration
+ * @returns a corresponding array of `Record<string, string>`
+ * @public
+ */
+export function parseRecordJarLines(lines, options) {
+    return RecordParser.parse(lines, options);
+}
+//# sourceMappingURL=recordJarHelpers.js.map