@fgv/ts-extras 5.0.0-2 → 5.0.0-21

package/src/packlets/experimental/rangeOf.ts

@@ -0,0 +1,222 @@
+/*
+ * 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 { Result, captureResult } from '@fgv/ts-utils';
+import Mustache from 'mustache';
+
+/**
+ * Represents a generic range of some comparable type `<T>`.
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export interface RangeOfProperties<T> {
+  readonly min?: T;
+  readonly max?: T;
+}
+
+/**
+ * Format strings (in mustache format) to
+ * use for both open-ended and complete
+ * {@link Experimental.RangeOf | RangeOf<T>}.
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export interface RangeOfFormats {
+  minOnly: string;
+  maxOnly: string;
+  minMax: string;
+}
+
+/**
+ * Default {@link Experimental.RangeOfFormats | formats} to use for both
+ * open-ended and complete {@link Experimental.RangeOf | RangeOf<T>}.
+ * @public
+ */
+export const DEFAULT_RANGEOF_FORMATS: RangeOfFormats = {
+  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<T> implements RangeOfProperties<T> {
+  /**
+   * Minimum extent of the range.
+   */
+  public readonly min?: T;
+  /**
+   * Maximum extent of the range.
+   */
+  public readonly max?: T;
+
+  /**
+   * Creates a new {@link Experimental.RangeOf | RangeOf<T>}.
+   * @param min - Optional minimum extent of the range.
+   * @param max - Optional maximum extent of the range.
+   */
+  public constructor(min?: T, max?: T) {
+    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>}.
+   */
+  public static createRange<T>(init?: RangeOfProperties<T>): Result<RangeOf<T>> {
+    return captureResult(() => new RangeOf<T>(init?.min, 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.
+   */
+  public static propertiesToString<T>(
+    range: RangeOfProperties<T>,
+    formats?: RangeOfFormats,
+    emptyValue?: T
+  ): string | undefined {
+    formats = 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
+   */
+  protected static _defaultCompare<T>(t1: T, t2: T): 'less' | 'equal' | 'greater' {
+    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.
+   */
+  public check(t: T): 'less' | 'included' | 'greater' {
+    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.
+   */
+  public includes(t: T): boolean {
+    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.
+   */
+  public findTransition(t: T): T | undefined {
+    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.
+   */
+  public toFormattedProperties(format: (value: T) => string | undefined): RangeOfProperties<string> {
+    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.
+   */
+  public format(format: (value: T) => string | undefined, formats?: RangeOfFormats): string | undefined {
+    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
+   */
+  protected _compare(t1: T, t2: T): 'less' | 'equal' | 'greater' {
+    return RangeOf._defaultCompare(t1, t2);
+  }
+}

package/src/packlets/hash/index.ts

@@ -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';

package/src/packlets/hash/md5Normalizer.ts

@@ -0,0 +1,38 @@
+/*
+ * 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 {
+  public constructor() {
+    super(Md5Normalizer.md5Hash);
+  }
+
+  public static md5Hash(parts: string[]): string {
+    return crypto.createHash('md5').update(parts.join('|'), 'utf8').digest('hex');
+  }
+}

package/src/packlets/record-jar/index.ts

@@ -0,0 +1,23 @@
+/*
+ * 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 * from './recordJarHelpers';

package/src/packlets/record-jar/recordJarHelpers.ts

@@ -0,0 +1,278 @@
+/*
+ * 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 { Result, captureResult, fail, isKeyOf, succeed } from '@fgv/ts-utils';
+
+interface IRecordBody {
+  body: string;
+  isContinuation: boolean;
+}
+
+/**
+ * Represents a single record in a JAR file
+ * @public
+ */
+export type JarRecord = Record<string, string | string[]>;
+
+/**
+ * @public
+ */
+export type JarFieldPicker<T extends JarRecord = JarRecord> = (record: T) => (keyof T)[];
+
+/**
+ * Options for a JAR record parser.
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export interface JarRecordParserOptions {
+  readonly arrayFields?: string[] | JarFieldPicker;
+  readonly fixedContinuationSize?: number;
+}
+
+class RecordParser {
+  public readonly records: JarRecord[] = [];
+  public readonly options: JarRecordParserOptions;
+
+  protected _fields: JarRecord = {};
+  protected _name: string | undefined = undefined;
+  protected _body: IRecordBody | undefined = undefined;
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor(options?: JarRecordParserOptions) {
+    this.options = options ?? {};
+  }
+
+  public static parse(lines: string[], options?: JarRecordParserOptions): Result<JarRecord[]> {
+    return new RecordParser(options)._parse(lines);
+  }
+
+  protected static _parseRecordBody(body: string): Result<IRecordBody> {
+    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 });
+  }
+
+  protected static _hasEscapes(from: string): boolean {
+    return from.includes('\\') || from.includes('&');
+  }
+
+  protected static _replaceEscapes(body: string): Result<string> {
+    const invalid: string[] = [];
+    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);
+  }
+
+  protected static _applyOptions(record: JarRecord, options: JarRecordParserOptions): JarRecord {
+    if (options.arrayFields) {
+      record = { ...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] as string;
+          record[field] = [current];
+        }
+      }
+    }
+    return record;
+  }
+
+  protected _parse(lines: string[]): Result<JarRecord[]> {
+    for (let n = 0; n < lines.length; n++) {
+      const line = lines[n];
+      if (line.startsWith('%%') && !this._body?.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 (this._body?.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);
+  }
+
+  protected _parseField(line: string): Result<boolean> {
+    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);
+      });
+    });
+  }
+
+  protected _parseContinuation(line: string): Result<IRecordBody> {
+    let trimmed = line.trim();
+    if (!this._body!.isContinuation) {
+      /* c8 ignore next */
+      const fixedSize = this.options?.fixedContinuationSize ?? 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
+      });
+    });
+  }
+
+  protected _havePendingRecord(): boolean {
+    return Object.keys(this._fields).length > 0;
+  }
+
+  protected _writePendingRecord(): Result<JarRecord | undefined> {
+    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);
+    });
+  }
+
+  protected _writePendingField(): Result<boolean> {
+    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] as string;
+        this._fields[this._name] = [current, this._body!.body];
+      } else {
+        const current = this._fields[this._name] as string[];
+        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: string[], options?: JarRecordParserOptions): Result<JarRecord[]> {
+  return RecordParser.parse(lines, options);
+}
+
+/**
+ * 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: string,
+  options?: JarRecordParserOptions
+): Result<JarRecord[]> {
+  return captureResult(() => {
+    const fullPath = path.resolve(srcPath);
+    return fs.readFileSync(fullPath, 'utf8').toString().split(/\r?\n/);
+  }).onSuccess((lines) => {
+    return parseRecordJarLines(lines, options);
+  });
+}

package/src/packlets/zip-file-tree/index.ts

@@ -0,0 +1,33 @@
+/*
+ * 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-based FileTree implementation for ts-extras.
+ *
+ * This packlet provides a FileTree accessor implementation that can read from ZIP archives,
+ * making it useful for browser environments where files need to be bundled and transferred
+ * as a single archive.
+ *
+ * @packageDocumentation
+ */
+
+export { ZipFileTreeAccessors, ZipFileItem, ZipDirectoryItem } from './zipFileTreeAccessors';