art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/pdf-lib/es/core/parser/PDFXRefStreamParser.js

@@ -0,0 +1,94 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('../errors.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFRef = require('../objects/PDFRef.js');
+var ByteStream = require('./ByteStream.js');
+
+var PDFXRefStreamParser = /** @class */ (function () {
+    function PDFXRefStreamParser(rawStream) {
+        this.alreadyParsed = false;
+        this.dict = rawStream.dict;
+        this.bytes = ByteStream.default.fromPDFRawStream(rawStream);
+        this.context = this.dict.context;
+        var Size = this.dict.lookup(PDFName.default.of('Size'), PDFNumber.default);
+        var Index = this.dict.lookup(PDFName.default.of('Index'));
+        if (Index instanceof PDFArray.default) {
+            this.subsections = [];
+            for (var idx = 0, len = Index.size(); idx < len; idx += 2) {
+                var firstObjectNumber = Index.lookup(idx + 0, PDFNumber.default).asNumber();
+                var length_1 = Index.lookup(idx + 1, PDFNumber.default).asNumber();
+                this.subsections.push({ firstObjectNumber: firstObjectNumber, length: length_1 });
+            }
+        }
+        else {
+            this.subsections = [{ firstObjectNumber: 0, length: Size.asNumber() }];
+        }
+        var W = this.dict.lookup(PDFName.default.of('W'), PDFArray.default);
+        this.byteWidths = [-1, -1, -1];
+        for (var idx = 0, len = W.size(); idx < len; idx++) {
+            this.byteWidths[idx] = W.lookup(idx, PDFNumber.default).asNumber();
+        }
+    }
+    PDFXRefStreamParser.prototype.parseIntoContext = function () {
+        if (this.alreadyParsed) {
+            throw new errors.ReparseError('PDFXRefStreamParser', 'parseIntoContext');
+        }
+        this.alreadyParsed = true;
+        this.context.trailerInfo = {
+            Root: this.dict.get(PDFName.default.of('Root')),
+            Encrypt: this.dict.get(PDFName.default.of('Encrypt')),
+            Info: this.dict.get(PDFName.default.of('Info')),
+            ID: this.dict.get(PDFName.default.of('ID')),
+        };
+        var entries = this.parseEntries();
+        // for (let idx = 0, len = entries.length; idx < len; idx++) {
+        // const entry = entries[idx];
+        // if (entry.deleted) this.context.delete(entry.ref);
+        // }
+        return entries;
+    };
+    PDFXRefStreamParser.prototype.parseEntries = function () {
+        var entries = [];
+        var _a = this.byteWidths, typeFieldWidth = _a[0], offsetFieldWidth = _a[1], genFieldWidth = _a[2];
+        for (var subsectionIdx = 0, subsectionLen = this.subsections.length; subsectionIdx < subsectionLen; subsectionIdx++) {
+            var _b = this.subsections[subsectionIdx], firstObjectNumber = _b.firstObjectNumber, length_2 = _b.length;
+            for (var objIdx = 0; objIdx < length_2; objIdx++) {
+                var type = 0;
+                for (var idx = 0, len = typeFieldWidth; idx < len; idx++) {
+                    type = (type << 8) | this.bytes.next();
+                }
+                var offset = 0;
+                for (var idx = 0, len = offsetFieldWidth; idx < len; idx++) {
+                    offset = (offset << 8) | this.bytes.next();
+                }
+                var generationNumber = 0;
+                for (var idx = 0, len = genFieldWidth; idx < len; idx++) {
+                    generationNumber = (generationNumber << 8) | this.bytes.next();
+                }
+                // When the `type` field is absent, it defaults to 1
+                if (typeFieldWidth === 0)
+                    type = 1;
+                var objectNumber = firstObjectNumber + objIdx;
+                var entry = {
+                    ref: PDFRef.default.of(objectNumber, generationNumber),
+                    offset: offset,
+                    deleted: type === 0,
+                    inObjectStream: type === 2,
+                };
+                entries.push(entry);
+            }
+        }
+        return entries;
+    };
+    PDFXRefStreamParser.forStream = function (rawStream) {
+        return new PDFXRefStreamParser(rawStream);
+    };
+    return PDFXRefStreamParser;
+}());
+
+exports.default = PDFXRefStreamParser;

package/dist/cjs/node_modules/pdf-lib/es/core/streams/Ascii85Stream.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var DecodeStream = require('./DecodeStream.js');
+
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The Ascii85Stream class contained in this file is a TypeScript port of the
+ * JavaScript Ascii85Stream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+var isSpace = function (ch) {
+    return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
+};
+var Ascii85Stream = /** @class */ (function (_super) {
+    tslib_es6.__extends(Ascii85Stream, _super);
+    function Ascii85Stream(stream, maybeLength) {
+        var _this = _super.call(this, maybeLength) || this;
+        _this.stream = stream;
+        _this.input = new Uint8Array(5);
+        // Most streams increase in size when decoded, but Ascii85 streams
+        // typically shrink by ~20%.
+        if (maybeLength) {
+            maybeLength = 0.8 * maybeLength;
+        }
+        return _this;
+    }
+    Ascii85Stream.prototype.readBlock = function () {
+        var TILDA_CHAR = 0x7e; // '~'
+        var Z_LOWER_CHAR = 0x7a; // 'z'
+        var EOF = -1;
+        var stream = this.stream;
+        var c = stream.getByte();
+        while (isSpace(c)) {
+            c = stream.getByte();
+        }
+        if (c === EOF || c === TILDA_CHAR) {
+            this.eof = true;
+            return;
+        }
+        var bufferLength = this.bufferLength;
+        var buffer;
+        var i;
+        // special code for z
+        if (c === Z_LOWER_CHAR) {
+            buffer = this.ensureBuffer(bufferLength + 4);
+            for (i = 0; i < 4; ++i) {
+                buffer[bufferLength + i] = 0;
+            }
+            this.bufferLength += 4;
+        }
+        else {
+            var input = this.input;
+            input[0] = c;
+            for (i = 1; i < 5; ++i) {
+                c = stream.getByte();
+                while (isSpace(c)) {
+                    c = stream.getByte();
+                }
+                input[i] = c;
+                if (c === EOF || c === TILDA_CHAR) {
+                    break;
+                }
+            }
+            buffer = this.ensureBuffer(bufferLength + i - 1);
+            this.bufferLength += i - 1;
+            // partial ending;
+            if (i < 5) {
+                for (; i < 5; ++i) {
+                    input[i] = 0x21 + 84;
+                }
+                this.eof = true;
+            }
+            var t = 0;
+            for (i = 0; i < 5; ++i) {
+                t = t * 85 + (input[i] - 0x21);
+            }
+            for (i = 3; i >= 0; --i) {
+                buffer[bufferLength + i] = t & 0xff;
+                t >>= 8;
+            }
+        }
+    };
+    return Ascii85Stream;
+}(DecodeStream.default));
+
+exports.default = Ascii85Stream;

package/dist/cjs/node_modules/pdf-lib/es/core/streams/AsciiHexStream.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var DecodeStream = require('./DecodeStream.js');
+
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The AsciiHexStream class contained in this file is a TypeScript port of the
+ * JavaScript AsciiHexStream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+var AsciiHexStream = /** @class */ (function (_super) {
+    tslib_es6.__extends(AsciiHexStream, _super);
+    function AsciiHexStream(stream, maybeLength) {
+        var _this = _super.call(this, maybeLength) || this;
+        _this.stream = stream;
+        _this.firstDigit = -1;
+        // Most streams increase in size when decoded, but AsciiHex streams shrink
+        // by 50%.
+        if (maybeLength) {
+            maybeLength = 0.5 * maybeLength;
+        }
+        return _this;
+    }
+    AsciiHexStream.prototype.readBlock = function () {
+        var UPSTREAM_BLOCK_SIZE = 8000;
+        var bytes = this.stream.getBytes(UPSTREAM_BLOCK_SIZE);
+        if (!bytes.length) {
+            this.eof = true;
+            return;
+        }
+        var maxDecodeLength = (bytes.length + 1) >> 1;
+        var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
+        var bufferLength = this.bufferLength;
+        var firstDigit = this.firstDigit;
+        for (var i = 0, ii = bytes.length; i < ii; i++) {
+            var ch = bytes[i];
+            var digit = void 0;
+            if (ch >= 0x30 && ch <= 0x39) {
+                // '0'-'9'
+                digit = ch & 0x0f;
+            }
+            else if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {
+                // 'A'-'Z', 'a'-'z'
+                digit = (ch & 0x0f) + 9;
+            }
+            else if (ch === 0x3e) {
+                // '>'
+                this.eof = true;
+                break;
+            }
+            else {
+                // probably whitespace
+                continue; // ignoring
+            }
+            if (firstDigit < 0) {
+                firstDigit = digit;
+            }
+            else {
+                buffer[bufferLength++] = (firstDigit << 4) | digit;
+                firstDigit = -1;
+            }
+        }
+        if (firstDigit >= 0 && this.eof) {
+            // incomplete byte
+            buffer[bufferLength++] = firstDigit << 4;
+            firstDigit = -1;
+        }
+        this.firstDigit = firstDigit;
+        this.bufferLength = bufferLength;
+    };
+    return AsciiHexStream;
+}(DecodeStream.default));
+
+exports.default = AsciiHexStream;

package/dist/cjs/node_modules/pdf-lib/es/core/streams/DecodeStream.js

@@ -0,0 +1,151 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('../errors.js');
+var Stream = require('./Stream.js');
+
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The DecodeStream class contained in this file is a TypeScript port of the
+ * JavaScript DecodeStream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+// Lots of DecodeStreams are created whose buffers are never used.  For these
+// we share a single empty buffer. This is (a) space-efficient and (b) avoids
+// having special cases that would be required if we used |null| for an empty
+// buffer.
+var emptyBuffer = new Uint8Array(0);
+/**
+ * Super class for the decoding streams
+ */
+var DecodeStream = /** @class */ (function () {
+    function DecodeStream(maybeMinBufferLength) {
+        this.pos = 0;
+        this.bufferLength = 0;
+        this.eof = false;
+        this.buffer = emptyBuffer;
+        this.minBufferLength = 512;
+        if (maybeMinBufferLength) {
+            // Compute the first power of two that is as big as maybeMinBufferLength.
+            while (this.minBufferLength < maybeMinBufferLength) {
+                this.minBufferLength *= 2;
+            }
+        }
+    }
+    Object.defineProperty(DecodeStream.prototype, "isEmpty", {
+        get: function () {
+            while (!this.eof && this.bufferLength === 0) {
+                this.readBlock();
+            }
+            return this.bufferLength === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DecodeStream.prototype.getByte = function () {
+        var pos = this.pos;
+        while (this.bufferLength <= pos) {
+            if (this.eof) {
+                return -1;
+            }
+            this.readBlock();
+        }
+        return this.buffer[this.pos++];
+    };
+    DecodeStream.prototype.getUint16 = function () {
+        var b0 = this.getByte();
+        var b1 = this.getByte();
+        if (b0 === -1 || b1 === -1) {
+            return -1;
+        }
+        return (b0 << 8) + b1;
+    };
+    DecodeStream.prototype.getInt32 = function () {
+        var b0 = this.getByte();
+        var b1 = this.getByte();
+        var b2 = this.getByte();
+        var b3 = this.getByte();
+        return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+    };
+    DecodeStream.prototype.getBytes = function (length, forceClamped) {
+        if (forceClamped === void 0) { forceClamped = false; }
+        var end;
+        var pos = this.pos;
+        if (length) {
+            this.ensureBuffer(pos + length);
+            end = pos + length;
+            while (!this.eof && this.bufferLength < end) {
+                this.readBlock();
+            }
+            var bufEnd = this.bufferLength;
+            if (end > bufEnd) {
+                end = bufEnd;
+            }
+        }
+        else {
+            while (!this.eof) {
+                this.readBlock();
+            }
+            end = this.bufferLength;
+        }
+        this.pos = end;
+        var subarray = this.buffer.subarray(pos, end);
+        // `this.buffer` is either a `Uint8Array` or `Uint8ClampedArray` here.
+        return forceClamped && !(subarray instanceof Uint8ClampedArray)
+            ? new Uint8ClampedArray(subarray)
+            : subarray;
+    };
+    DecodeStream.prototype.peekByte = function () {
+        var peekedByte = this.getByte();
+        this.pos--;
+        return peekedByte;
+    };
+    DecodeStream.prototype.peekBytes = function (length, forceClamped) {
+        if (forceClamped === void 0) { forceClamped = false; }
+        var bytes = this.getBytes(length, forceClamped);
+        this.pos -= bytes.length;
+        return bytes;
+    };
+    DecodeStream.prototype.skip = function (n) {
+        if (!n) {
+            n = 1;
+        }
+        this.pos += n;
+    };
+    DecodeStream.prototype.reset = function () {
+        this.pos = 0;
+    };
+    DecodeStream.prototype.makeSubStream = function (start, length /* dict */) {
+        var end = start + length;
+        while (this.bufferLength <= end && !this.eof) {
+            this.readBlock();
+        }
+        return new Stream.default(this.buffer, start, length /* dict */);
+    };
+    DecodeStream.prototype.decode = function () {
+        while (!this.eof)
+            this.readBlock();
+        return this.buffer.subarray(0, this.bufferLength);
+    };
+    DecodeStream.prototype.readBlock = function () {
+        throw new errors.MethodNotImplementedError(this.constructor.name, 'readBlock');
+    };
+    DecodeStream.prototype.ensureBuffer = function (requested) {
+        var buffer = this.buffer;
+        if (requested <= buffer.byteLength) {
+            return buffer;
+        }
+        var size = this.minBufferLength;
+        while (size < requested) {
+            size *= 2;
+        }
+        var buffer2 = new Uint8Array(size);
+        buffer2.set(buffer);
+        return (this.buffer = buffer2);
+    };
+    return DecodeStream;
+}());
+
+exports.default = DecodeStream;