@cj-tech-master/excelts 4.2.1-canary.20260111102127.f808a37 → 4.2.1

package/dist/esm/modules/archive/io/archive-source.js

@@ -1,107 +0,0 @@
-import { encodeUtf8 } from "../utils/text.js";
-export function isReadableStream(value) {
-    return !!value && typeof value === "object" && typeof value.getReader === "function";
-}
-export function isAsyncIterable(value) {
-    return (!!value &&
-        (typeof value === "object" || typeof value === "function") &&
-        typeof value[Symbol.asyncIterator] === "function");
-}
-function normalizeChunk(value) {
-    if (!value) {
-        return null;
-    }
-    if (value instanceof Uint8Array) {
-        return value.length ? value : null;
-    }
-    if (typeof value === "string") {
-        const bytes = encodeUtf8(value);
-        return bytes.length ? bytes : null;
-    }
-    if (value instanceof ArrayBuffer) {
-        return value.byteLength ? new Uint8Array(value) : null;
-    }
-    if (ArrayBuffer.isView(value)) {
-        return value.byteLength
-            ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
-            : null;
-    }
-    // Best-effort: treat unknown chunk as Uint8Array-like.
-    if (typeof value.length === "number" && value.length) {
-        return value;
-    }
-    return null;
-}
-export function toUint8ArraySync(source) {
-    if (source instanceof Uint8Array) {
-        return source;
-    }
-    if (typeof source === "string") {
-        return encodeUtf8(source);
-    }
-    return new Uint8Array(source);
-}
-export async function toUint8Array(source) {
-    if (source instanceof Uint8Array) {
-        return source;
-    }
-    if (typeof source === "string") {
-        return encodeUtf8(source);
-    }
-    if (source instanceof ArrayBuffer) {
-        return new Uint8Array(source);
-    }
-    const buf = await source.arrayBuffer();
-    return new Uint8Array(buf);
-}
-export async function* toAsyncIterable(source) {
-    if (source instanceof Uint8Array) {
-        yield source;
-        return;
-    }
-    if (typeof source === "string") {
-        yield encodeUtf8(source);
-        return;
-    }
-    if (source instanceof ArrayBuffer) {
-        yield new Uint8Array(source);
-        return;
-    }
-    if (typeof Blob !== "undefined" && source instanceof Blob) {
-        yield await toUint8Array(source);
-        return;
-    }
-    if (isReadableStream(source)) {
-        const reader = source.getReader();
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    return;
-                }
-                const chunk = normalizeChunk(value);
-                if (chunk) {
-                    yield chunk;
-                }
-            }
-        }
-        finally {
-            try {
-                reader.releaseLock();
-            }
-            catch {
-                // Ignore
-            }
-        }
-    }
-    if (isAsyncIterable(source)) {
-        for await (const value of source) {
-            const chunk = normalizeChunk(value);
-            if (chunk) {
-                yield chunk;
-            }
-        }
-        return;
-    }
-    throw new Error("Unsupported archive source");
-}

package/dist/esm/modules/archive/unzip/index.js

@@ -1,164 +0,0 @@
-import { ZipParser } from "./zip-parser.js";
-import { createParse } from "./stream.js";
-import { pipeIterableToSink } from "../io/archive-sink.js";
-import { toAsyncIterable, toUint8Array } from "../io/archive-source.js";
-const textDecoderCache = new Map();
-function getTextDecoder(encoding) {
-    const key = encoding ?? "utf-8";
-    const cached = textDecoderCache.get(key);
-    if (cached) {
-        return cached;
-    }
-    const decoder = new TextDecoder(key);
-    textDecoderCache.set(key, decoder);
-    return decoder;
-}
-export class UnzipEntry {
-    constructor(args) {
-        if (args.kind === "buffer") {
-            this._parser = args.parser;
-            this._info = args.info;
-            this.path = args.info.path;
-            this.isDirectory = args.info.isDirectory;
-        }
-        else {
-            this._parseEntry = args.entry;
-            this.path = args.entry.path;
-            this.isDirectory = args.entry.type === "Directory";
-        }
-    }
-    async bytes() {
-        if (this._parser && this._info) {
-            const out = await this._parser.extract(this._info.path);
-            return out ?? new Uint8Array(0);
-        }
-        if (this._parseEntry) {
-            const data = await this._parseEntry.buffer();
-            // In Node.js, `entry.buffer()` may return a Buffer, which causes
-            // deep-equality mismatches against Uint8Array in tests.
-            if (typeof Buffer !== "undefined" && data instanceof Buffer) {
-                return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-            }
-            return data;
-        }
-        return new Uint8Array(0);
-    }
-    async *stream() {
-        if (this._parser && this._info) {
-            const data = await this.bytes();
-            if (data.length) {
-                yield data;
-            }
-            return;
-        }
-        if (this._parseEntry) {
-            for await (const chunk of this._parseEntry) {
-                yield chunk;
-            }
-        }
-    }
-    async pipeTo(sink) {
-        await pipeIterableToSink(this.stream(), sink);
-    }
-    async text(encoding) {
-        const bytes = await this.bytes();
-        return getTextDecoder(encoding).decode(bytes);
-    }
-    discard() {
-        if (this._parseEntry) {
-            this._parseEntry.autodrain();
-        }
-    }
-}
-export class ZipReader {
-    constructor(source, options = {}) {
-        this._bufferParser = null;
-        this._source = source;
-        this._options = options;
-    }
-    async _ensureBufferParser() {
-        if (this._bufferParser) {
-            return this._bufferParser;
-        }
-        if (this._source instanceof Uint8Array ||
-            this._source instanceof ArrayBuffer ||
-            typeof this._source === "string" ||
-            (typeof Blob !== "undefined" && this._source instanceof Blob)) {
-            const bytes = await toUint8Array(this._source);
-            this._bufferParser = new ZipParser(bytes, {
-                decodeStrings: this._options.decodeStrings
-            });
-            return this._bufferParser;
-        }
-        throw new Error("This ZIP source is streaming; random access is not available");
-    }
-    async get(path) {
-        const parser = await this._ensureBufferParser();
-        const info = parser.getEntry(path);
-        if (!info) {
-            return null;
-        }
-        return new UnzipEntry({ kind: "buffer", parser, info });
-    }
-    async *entries() {
-        // Buffer mode
-        if (this._source instanceof Uint8Array ||
-            this._source instanceof ArrayBuffer ||
-            typeof this._source === "string" ||
-            (typeof Blob !== "undefined" && this._source instanceof Blob)) {
-            const parser = await this._ensureBufferParser();
-            for (const info of parser.getEntries()) {
-                yield new UnzipEntry({ kind: "buffer", parser, info });
-            }
-            return;
-        }
-        // Streaming mode
-        // Always prefer forceStream mode for backpressure and bounded buffering.
-        const parse = createParse({ ...(this._options.parse ?? {}), forceStream: true });
-        const feedPromise = (async () => {
-            try {
-                for await (const chunk of toAsyncIterable(this._source)) {
-                    await new Promise((resolve, reject) => {
-                        parse.write(chunk, (err) => {
-                            if (err) {
-                                reject(err);
-                            }
-                            else {
-                                resolve();
-                            }
-                        });
-                    });
-                }
-                parse.end();
-                await parse.promise();
-            }
-            catch (e) {
-                parse.destroy(e instanceof Error ? e : new Error(String(e)));
-                throw e;
-            }
-        })();
-        try {
-            for await (const entry of parse) {
-                yield new UnzipEntry({ kind: "stream", entry });
-            }
-            await feedPromise;
-        }
-        finally {
-            // Ensure the feed task does not get stranded.
-            await feedPromise.catch(() => { });
-        }
-    }
-    async bytes(path) {
-        const entry = await this.get(path);
-        if (!entry) {
-            return null;
-        }
-        return entry.bytes();
-    }
-    async close() {
-        // No persistent resources in buffer mode.
-    }
-}
-export function unzip(source, options) {
-    return new ZipReader(source, options);
-}