@taloswork/ose-shared 0.1.11 → 0.1.13

package/skills/document/bin/pdf-ops.cjs

@@ -743,31 +743,31 @@ var require_unicode = __commonJS({
       if (byteOrderMark)
         encoded.push(239, 187, 191);
       for (var idx = 0, len = input.length; idx < len; ) {
-        var codePoint = input.codePointAt(idx);
-        if (codePoint < 128) {
-          var byte1 = codePoint & 127;
+        var codePoint2 = input.codePointAt(idx);
+        if (codePoint2 < 128) {
+          var byte1 = codePoint2 & 127;
           encoded.push(byte1);
           idx += 1;
-        } else if (codePoint < 2048) {
-          var byte1 = codePoint >> 6 & 31 | 192;
-          var byte2 = codePoint & 63 | 128;
+        } else if (codePoint2 < 2048) {
+          var byte1 = codePoint2 >> 6 & 31 | 192;
+          var byte2 = codePoint2 & 63 | 128;
           encoded.push(byte1, byte2);
           idx += 1;
-        } else if (codePoint < 65536) {
-          var byte1 = codePoint >> 12 & 15 | 224;
-          var byte2 = codePoint >> 6 & 63 | 128;
-          var byte3 = codePoint & 63 | 128;
+        } else if (codePoint2 < 65536) {
+          var byte1 = codePoint2 >> 12 & 15 | 224;
+          var byte2 = codePoint2 >> 6 & 63 | 128;
+          var byte3 = codePoint2 & 63 | 128;
           encoded.push(byte1, byte2, byte3);
           idx += 1;
-        } else if (codePoint < 1114112) {
-          var byte1 = codePoint >> 18 & 7 | 240;
-          var byte2 = codePoint >> 12 & 63 | 128;
-          var byte3 = codePoint >> 6 & 63 | 128;
-          var byte4 = codePoint >> 0 & 63 | 128;
+        } else if (codePoint2 < 1114112) {
+          var byte1 = codePoint2 >> 18 & 7 | 240;
+          var byte2 = codePoint2 >> 12 & 63 | 128;
+          var byte3 = codePoint2 >> 6 & 63 | 128;
+          var byte4 = codePoint2 >> 0 & 63 | 128;
           encoded.push(byte1, byte2, byte3, byte4);
           idx += 2;
         } else
-          throw new Error("Invalid code point: 0x" + strings_1.toHexString(codePoint));
+          throw new Error("Invalid code point: 0x" + strings_1.toHexString(codePoint2));
       }
       return new Uint8Array(encoded);
     };
@@ -779,29 +779,29 @@ var require_unicode = __commonJS({
       if (byteOrderMark)
         encoded.push(65279);
       for (var idx = 0, len = input.length; idx < len; ) {
-        var codePoint = input.codePointAt(idx);
-        if (codePoint < 65536) {
-          encoded.push(codePoint);
+        var codePoint2 = input.codePointAt(idx);
+        if (codePoint2 < 65536) {
+          encoded.push(codePoint2);
           idx += 1;
-        } else if (codePoint < 1114112) {
-          encoded.push(exports2.highSurrogate(codePoint), exports2.lowSurrogate(codePoint));
+        } else if (codePoint2 < 1114112) {
+          encoded.push(exports2.highSurrogate(codePoint2), exports2.lowSurrogate(codePoint2));
           idx += 2;
         } else
-          throw new Error("Invalid code point: 0x" + strings_1.toHexString(codePoint));
+          throw new Error("Invalid code point: 0x" + strings_1.toHexString(codePoint2));
       }
       return new Uint16Array(encoded);
     };
-    exports2.isWithinBMP = function(codePoint) {
-      return codePoint >= 0 && codePoint <= 65535;
+    exports2.isWithinBMP = function(codePoint2) {
+      return codePoint2 >= 0 && codePoint2 <= 65535;
     };
-    exports2.hasSurrogates = function(codePoint) {
-      return codePoint >= 65536 && codePoint <= 1114111;
+    exports2.hasSurrogates = function(codePoint2) {
+      return codePoint2 >= 65536 && codePoint2 <= 1114111;
     };
-    exports2.highSurrogate = function(codePoint) {
-      return Math.floor((codePoint - 65536) / 1024) + 55296;
+    exports2.highSurrogate = function(codePoint2) {
+      return Math.floor((codePoint2 - 65536) / 1024) + 55296;
     };
-    exports2.lowSurrogate = function(codePoint) {
-      return (codePoint - 65536) % 1024 + 56320;
+    exports2.lowSurrogate = function(codePoint2) {
+      return (codePoint2 - 65536) % 1024 + 56320;
     };
     var ByteOrder;
     (function(ByteOrder2) {
@@ -842,11 +842,11 @@ var require_unicode = __commonJS({
         codePoints.push(REPLACEMENT);
       return String.fromCodePoint.apply(String, codePoints);
     };
-    var isHighSurrogate = function(codePoint) {
-      return codePoint >= 55296 && codePoint <= 56319;
+    var isHighSurrogate = function(codePoint2) {
+      return codePoint2 >= 55296 && codePoint2 <= 56319;
     };
-    var isLowSurrogate = function(codePoint) {
-      return codePoint >= 56320 && codePoint <= 57343;
+    var isLowSurrogate = function(codePoint2) {
+      return codePoint2 >= 56320 && codePoint2 <= 57343;
     };
     var decodeValues = function(first, second, byteOrder) {
       if (byteOrder === ByteOrder.LittleEndian)
@@ -5427,14 +5427,14 @@ var require_Encoding = __commonJS({
       /* @__PURE__ */ (function() {
         function Encoding2(name, unicodeMappings) {
           var _this = this;
-          this.canEncodeUnicodeCodePoint = function(codePoint) {
-            return codePoint in _this.unicodeMappings;
+          this.canEncodeUnicodeCodePoint = function(codePoint2) {
+            return codePoint2 in _this.unicodeMappings;
           };
-          this.encodeUnicodeCodePoint = function(codePoint) {
-            var mapped = _this.unicodeMappings[codePoint];
+          this.encodeUnicodeCodePoint = function(codePoint2) {
+            var mapped = _this.unicodeMappings[codePoint2];
             if (!mapped) {
-              var str = String.fromCharCode(codePoint);
-              var hexCode = "0x" + utils_1.padStart(codePoint.toString(16), 4, "0");
+              var str = String.fromCharCode(codePoint2);
+              var hexCode = "0x" + utils_1.padStart(codePoint2.toString(16), 4, "0");
               var msg = _this.name + ' cannot encode "' + str + '" (' + hexCode + ")";
               throw new Error(msg);
             }
@@ -8864,16 +8864,16 @@ var require_StandardFontEmbedder = __commonJS({
     var standard_fonts_1 = require_lib();
     var PDFHexString_1 = tslib_1.__importDefault(require_PDFHexString());
     var utils_1 = require_utils2();
-    var StandardFontEmbedder = (
+    var StandardFontEmbedder2 = (
       /** @class */
       (function() {
-        function StandardFontEmbedder2(fontName, customName) {
+        function StandardFontEmbedder3(fontName, customName) {
           this.encoding = fontName === standard_fonts_1.FontNames.ZapfDingbats ? standard_fonts_1.Encodings.ZapfDingbats : fontName === standard_fonts_1.FontNames.Symbol ? standard_fonts_1.Encodings.Symbol : standard_fonts_1.Encodings.WinAnsi;
           this.font = standard_fonts_1.Font.load(fontName);
           this.fontName = this.font.FontName;
           this.customName = customName;
         }
-        StandardFontEmbedder2.prototype.encodeText = function(text) {
+        StandardFontEmbedder3.prototype.encodeText = function(text) {
           var glyphs = this.encodeTextAsGlyphs(text);
           var hexCodes = new Array(glyphs.length);
           for (var idx = 0, len = glyphs.length; idx < len; idx++) {
@@ -8881,7 +8881,7 @@ var require_StandardFontEmbedder = __commonJS({
           }
           return PDFHexString_1.default.of(hexCodes.join(""));
         };
-        StandardFontEmbedder2.prototype.widthOfTextAtSize = function(text, size) {
+        StandardFontEmbedder3.prototype.widthOfTextAtSize = function(text, size) {
           var glyphs = this.encodeTextAsGlyphs(text);
           var totalWidth = 0;
           for (var idx = 0, len = glyphs.length; idx < len; idx++) {
@@ -8893,7 +8893,7 @@ var require_StandardFontEmbedder = __commonJS({
           var scale = size / 1e3;
           return totalWidth * scale;
         };
-        StandardFontEmbedder2.prototype.heightOfFontAtSize = function(size, options) {
+        StandardFontEmbedder3.prototype.heightOfFontAtSize = function(size, options) {
           if (options === void 0) {
             options = {};
           }
@@ -8906,13 +8906,13 @@ var require_StandardFontEmbedder = __commonJS({
             height += Descender || 0;
           return height / 1e3 * size;
         };
-        StandardFontEmbedder2.prototype.sizeOfFontAtHeight = function(height) {
+        StandardFontEmbedder3.prototype.sizeOfFontAtHeight = function(height) {
           var _a = this.font, Ascender = _a.Ascender, Descender = _a.Descender, FontBBox = _a.FontBBox;
           var yTop = Ascender || FontBBox[3];
           var yBottom = Descender || FontBBox[1];
           return 1e3 * height / (yTop - yBottom);
         };
-        StandardFontEmbedder2.prototype.embedIntoContext = function(context, ref) {
+        StandardFontEmbedder3.prototype.embedIntoContext = function(context, ref) {
           var fontDict = context.obj({
             Type: "Font",
             Subtype: "Type1",
@@ -8926,25 +8926,25 @@ var require_StandardFontEmbedder = __commonJS({
             return context.register(fontDict);
           }
         };
-        StandardFontEmbedder2.prototype.widthOfGlyph = function(glyphName) {
+        StandardFontEmbedder3.prototype.widthOfGlyph = function(glyphName) {
           return this.font.getWidthOfGlyph(glyphName) || 250;
         };
-        StandardFontEmbedder2.prototype.encodeTextAsGlyphs = function(text) {
+        StandardFontEmbedder3.prototype.encodeTextAsGlyphs = function(text) {
           var codePoints = Array.from(text);
           var glyphs = new Array(codePoints.length);
           for (var idx = 0, len = codePoints.length; idx < len; idx++) {
-            var codePoint = utils_1.toCodePoint(codePoints[idx]);
-            glyphs[idx] = this.encoding.encodeUnicodeCodePoint(codePoint);
+            var codePoint2 = utils_1.toCodePoint(codePoints[idx]);
+            glyphs[idx] = this.encoding.encodeUnicodeCodePoint(codePoint2);
           }
           return glyphs;
         };
-        StandardFontEmbedder2.for = function(fontName, customName) {
-          return new StandardFontEmbedder2(fontName, customName);
+        StandardFontEmbedder3.for = function(fontName, customName) {
+          return new StandardFontEmbedder3(fontName, customName);
         };
-        return StandardFontEmbedder2;
+        return StandardFontEmbedder3;
       })()
     );
-    exports2.default = StandardFontEmbedder;
+    exports2.default = StandardFontEmbedder2;
   }
 });
 
@@ -8968,8 +8968,8 @@ var require_CMap = __commonJS({
     };
     var fillCmapTemplate = function(bfChars) {
       return "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo <<\n  /Registry (Adobe)\n  /Ordering (UCS)\n  /Supplement 0\n>> def\n/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000><ffff>\nendcodespacerange\n" + bfChars.length + " beginbfchar\n" + bfChars.map(function(_a) {
-        var glyphId = _a[0], codePoint = _a[1];
-        return glyphId + " " + codePoint;
+        var glyphId = _a[0], codePoint2 = _a[1];
+        return glyphId + " " + codePoint2;
       }).join("\n") + "\nendbfchar\nendcmap\nCMapName currentdict /CMap defineresource pop\nend\nend";
     };
     var cmapHexFormat = function() {
@@ -8982,15 +8982,15 @@ var require_CMap = __commonJS({
     var cmapHexString = function(value) {
       return utils_1.toHexStringOfMinLength(value, 4);
     };
-    var cmapCodePointFormat = function(codePoint) {
-      if (unicode_1.isWithinBMP(codePoint))
-        return cmapHexString(codePoint);
-      if (unicode_1.hasSurrogates(codePoint)) {
-        var hs = unicode_1.highSurrogate(codePoint);
-        var ls = unicode_1.lowSurrogate(codePoint);
+    var cmapCodePointFormat = function(codePoint2) {
+      if (unicode_1.isWithinBMP(codePoint2))
+        return cmapHexString(codePoint2);
+      if (unicode_1.hasSurrogates(codePoint2)) {
+        var hs = unicode_1.highSurrogate(codePoint2);
+        var ls = unicode_1.lowSurrogate(codePoint2);
         return "" + cmapHexString(hs) + cmapHexString(ls);
       }
-      var hex = utils_1.toHexString(codePoint);
+      var hex = utils_1.toHexString(codePoint2);
       var msg = "0x" + hex + " is not a valid UTF-8 or UTF-16 codepoint.";
       throw new Error(msg);
     };
@@ -9182,8 +9182,8 @@ var require_CustomFontEmbedder = __commonJS({
           this.allGlyphsInFontSortedById = function() {
             var glyphs = new Array(_this.font.characterSet.length);
             for (var idx = 0, len = glyphs.length; idx < len; idx++) {
-              var codePoint = _this.font.characterSet[idx];
-              glyphs[idx] = _this.font.glyphForCodePoint(codePoint);
+              var codePoint2 = _this.font.characterSet[idx];
+              glyphs[idx] = _this.font.glyphForCodePoint(codePoint2);
             }
             return utils_1.sortedUniq(glyphs.sort(utils_1.byAscendingId), function(g) {
               return g.id;
@@ -17457,20 +17457,20 @@ var require_errors3 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.InvalidMaxLengthError = exports2.ExceededMaxLengthError = exports2.CombedTextLayoutError = exports2.RichTextFieldReadError = exports2.FieldExistsAsNonTerminalError = exports2.InvalidFieldNamePartError = exports2.FieldAlreadyExistsError = exports2.MissingOnValueCheckError = exports2.UnexpectedFieldTypeError = exports2.NoSuchFieldError = exports2.RemovePageFromEmptyDocumentError = exports2.ForeignPageError = exports2.FontkitNotRegisteredError = exports2.EncryptedPDFError = void 0;
     var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
-    var EncryptedPDFError = (
+    var EncryptedPDFError2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(EncryptedPDFError2, _super);
-        function EncryptedPDFError2() {
+        tslib_1.__extends(EncryptedPDFError3, _super);
+        function EncryptedPDFError3() {
           var _this = this;
           var msg = "Input document to `PDFDocument.load` is encrypted. You can use `PDFDocument.load(..., { ignoreEncryption: true })` if you wish to load the document anyways.";
           _this = _super.call(this, msg) || this;
           return _this;
         }
-        return EncryptedPDFError2;
+        return EncryptedPDFError3;
       })(Error)
     );
-    exports2.EncryptedPDFError = EncryptedPDFError;
+    exports2.EncryptedPDFError = EncryptedPDFError2;
     var FontkitNotRegisteredError = (
       /** @class */
       (function(_super) {
@@ -20399,10 +20399,10 @@ var require_PDFDocument = __commonJS({
     var PDFEmbeddedFile_1 = tslib_1.__importDefault(require_PDFEmbeddedFile());
     var PDFJavaScript_1 = tslib_1.__importDefault(require_PDFJavaScript());
     var JavaScriptEmbedder_1 = tslib_1.__importDefault(require_JavaScriptEmbedder());
-    var PDFDocument2 = (
+    var PDFDocument3 = (
       /** @class */
       (function() {
-        function PDFDocument3(context, ignoreEncryption, updateMetadata) {
+        function PDFDocument4(context, ignoreEncryption, updateMetadata) {
           var _this = this;
           this.defaultWordBreaks = [" "];
           this.computePages = function() {
@@ -20441,7 +20441,7 @@ var require_PDFDocument = __commonJS({
           if (updateMetadata)
             this.updateInfoDict();
         }
-        PDFDocument3.load = function(pdf, options) {
+        PDFDocument4.load = function(pdf, options) {
           if (options === void 0) {
             options = {};
           }
@@ -20459,12 +20459,12 @@ var require_PDFDocument = __commonJS({
                   return [4, core_1.PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, capNumbers).parseDocument()];
                 case 1:
                   context = _f.sent();
-                  return [2, new PDFDocument3(context, ignoreEncryption, updateMetadata)];
+                  return [2, new PDFDocument4(context, ignoreEncryption, updateMetadata)];
               }
             });
           });
         };
-        PDFDocument3.create = function(options) {
+        PDFDocument4.create = function(options) {
           if (options === void 0) {
             options = {};
           }
@@ -20477,14 +20477,14 @@ var require_PDFDocument = __commonJS({
               pageTreeRef = context.register(pageTree);
               catalog = core_1.PDFCatalog.withContextAndPages(context, pageTreeRef);
               context.trailerInfo.Root = context.register(catalog);
-              return [2, new PDFDocument3(context, false, updateMetadata)];
+              return [2, new PDFDocument4(context, false, updateMetadata)];
             });
           });
         };
-        PDFDocument3.prototype.registerFontkit = function(fontkit) {
+        PDFDocument4.prototype.registerFontkit = function(fontkit) {
           this.fontkit = fontkit;
         };
-        PDFDocument3.prototype.getForm = function() {
+        PDFDocument4.prototype.getForm = function() {
           var form = this.formCache.access();
           if (form.hasXFA()) {
             console.warn("Removing XFA form data as pdf-lib does not support reading or writing XFA");
@@ -20492,63 +20492,63 @@ var require_PDFDocument = __commonJS({
           }
           return form;
         };
-        PDFDocument3.prototype.getTitle = function() {
+        PDFDocument4.prototype.getTitle = function() {
           var title = this.getInfoDict().lookup(core_1.PDFName.Title);
           if (!title)
             return void 0;
           assertIsLiteralOrHexString(title);
           return title.decodeText();
         };
-        PDFDocument3.prototype.getAuthor = function() {
+        PDFDocument4.prototype.getAuthor = function() {
           var author = this.getInfoDict().lookup(core_1.PDFName.Author);
           if (!author)
             return void 0;
           assertIsLiteralOrHexString(author);
           return author.decodeText();
         };
-        PDFDocument3.prototype.getSubject = function() {
+        PDFDocument4.prototype.getSubject = function() {
           var subject = this.getInfoDict().lookup(core_1.PDFName.Subject);
           if (!subject)
             return void 0;
           assertIsLiteralOrHexString(subject);
           return subject.decodeText();
         };
-        PDFDocument3.prototype.getKeywords = function() {
+        PDFDocument4.prototype.getKeywords = function() {
           var keywords = this.getInfoDict().lookup(core_1.PDFName.Keywords);
           if (!keywords)
             return void 0;
           assertIsLiteralOrHexString(keywords);
           return keywords.decodeText();
         };
-        PDFDocument3.prototype.getCreator = function() {
+        PDFDocument4.prototype.getCreator = function() {
           var creator = this.getInfoDict().lookup(core_1.PDFName.Creator);
           if (!creator)
             return void 0;
           assertIsLiteralOrHexString(creator);
           return creator.decodeText();
         };
-        PDFDocument3.prototype.getProducer = function() {
+        PDFDocument4.prototype.getProducer = function() {
           var producer = this.getInfoDict().lookup(core_1.PDFName.Producer);
           if (!producer)
             return void 0;
           assertIsLiteralOrHexString(producer);
           return producer.decodeText();
         };
-        PDFDocument3.prototype.getCreationDate = function() {
+        PDFDocument4.prototype.getCreationDate = function() {
           var creationDate = this.getInfoDict().lookup(core_1.PDFName.CreationDate);
           if (!creationDate)
             return void 0;
           assertIsLiteralOrHexString(creationDate);
           return creationDate.decodeDate();
         };
-        PDFDocument3.prototype.getModificationDate = function() {
+        PDFDocument4.prototype.getModificationDate = function() {
           var modificationDate = this.getInfoDict().lookup(core_1.PDFName.ModDate);
           if (!modificationDate)
             return void 0;
           assertIsLiteralOrHexString(modificationDate);
           return modificationDate.decodeDate();
         };
-        PDFDocument3.prototype.setTitle = function(title, options) {
+        PDFDocument4.prototype.setTitle = function(title, options) {
           utils_1.assertIs(title, "title", ["string"]);
           var key = core_1.PDFName.of("Title");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(title));
@@ -20557,63 +20557,63 @@ var require_PDFDocument = __commonJS({
             prefs.setDisplayDocTitle(true);
           }
         };
-        PDFDocument3.prototype.setAuthor = function(author) {
+        PDFDocument4.prototype.setAuthor = function(author) {
           utils_1.assertIs(author, "author", ["string"]);
           var key = core_1.PDFName.of("Author");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(author));
         };
-        PDFDocument3.prototype.setSubject = function(subject) {
+        PDFDocument4.prototype.setSubject = function(subject) {
           utils_1.assertIs(subject, "author", ["string"]);
           var key = core_1.PDFName.of("Subject");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(subject));
         };
-        PDFDocument3.prototype.setKeywords = function(keywords) {
+        PDFDocument4.prototype.setKeywords = function(keywords) {
           utils_1.assertIs(keywords, "keywords", [Array]);
           var key = core_1.PDFName.of("Keywords");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(keywords.join(" ")));
         };
-        PDFDocument3.prototype.setCreator = function(creator) {
+        PDFDocument4.prototype.setCreator = function(creator) {
           utils_1.assertIs(creator, "creator", ["string"]);
           var key = core_1.PDFName.of("Creator");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(creator));
         };
-        PDFDocument3.prototype.setProducer = function(producer) {
+        PDFDocument4.prototype.setProducer = function(producer) {
           utils_1.assertIs(producer, "creator", ["string"]);
           var key = core_1.PDFName.of("Producer");
           this.getInfoDict().set(key, core_1.PDFHexString.fromText(producer));
         };
-        PDFDocument3.prototype.setLanguage = function(language) {
+        PDFDocument4.prototype.setLanguage = function(language) {
           utils_1.assertIs(language, "language", ["string"]);
           var key = core_1.PDFName.of("Lang");
           this.catalog.set(key, core_1.PDFString.of(language));
         };
-        PDFDocument3.prototype.setCreationDate = function(creationDate) {
+        PDFDocument4.prototype.setCreationDate = function(creationDate) {
           utils_1.assertIs(creationDate, "creationDate", [[Date, "Date"]]);
           var key = core_1.PDFName.of("CreationDate");
           this.getInfoDict().set(key, core_1.PDFString.fromDate(creationDate));
         };
-        PDFDocument3.prototype.setModificationDate = function(modificationDate) {
+        PDFDocument4.prototype.setModificationDate = function(modificationDate) {
           utils_1.assertIs(modificationDate, "modificationDate", [[Date, "Date"]]);
           var key = core_1.PDFName.of("ModDate");
           this.getInfoDict().set(key, core_1.PDFString.fromDate(modificationDate));
         };
-        PDFDocument3.prototype.getPageCount = function() {
+        PDFDocument4.prototype.getPageCount = function() {
           if (this.pageCount === void 0)
             this.pageCount = this.getPages().length;
           return this.pageCount;
         };
-        PDFDocument3.prototype.getPages = function() {
+        PDFDocument4.prototype.getPages = function() {
           return this.pageCache.access();
         };
-        PDFDocument3.prototype.getPage = function(index) {
+        PDFDocument4.prototype.getPage = function(index) {
           var pages = this.getPages();
           utils_1.assertRange(index, "index", 0, pages.length - 1);
           return pages[index];
         };
-        PDFDocument3.prototype.getPageIndices = function() {
+        PDFDocument4.prototype.getPageIndices = function() {
           return utils_1.range(0, this.getPageCount());
         };
-        PDFDocument3.prototype.removePage = function(index) {
+        PDFDocument4.prototype.removePage = function(index) {
           var pageCount = this.getPageCount();
           if (this.pageCount === 0)
             throw new errors_1.RemovePageFromEmptyDocumentError();
@@ -20621,11 +20621,11 @@ var require_PDFDocument = __commonJS({
           this.catalog.removeLeafNode(index);
           this.pageCount = pageCount - 1;
         };
-        PDFDocument3.prototype.addPage = function(page) {
+        PDFDocument4.prototype.addPage = function(page) {
           utils_1.assertIs(page, "page", ["undefined", [PDFPage_1.default, "PDFPage"], Array]);
           return this.insertPage(this.getPageCount(), page);
         };
-        PDFDocument3.prototype.insertPage = function(index, page) {
+        PDFDocument4.prototype.insertPage = function(index, page) {
           var pageCount = this.getPageCount();
           utils_1.assertRange(index, "index", 0, pageCount);
           utils_1.assertIs(page, "page", ["undefined", [PDFPage_1.default, "PDFPage"], Array]);
@@ -20643,13 +20643,13 @@ var require_PDFDocument = __commonJS({
           this.pageCount = pageCount + 1;
           return page;
         };
-        PDFDocument3.prototype.copyPages = function(srcDoc, indices) {
+        PDFDocument4.prototype.copyPages = function(srcDoc, indices) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var copier, srcPages, copiedPages, idx, len, srcPage, copiedPage, ref;
             return tslib_1.__generator(this, function(_a) {
               switch (_a.label) {
                 case 0:
-                  utils_1.assertIs(srcDoc, "srcDoc", [[PDFDocument3, "PDFDocument"]]);
+                  utils_1.assertIs(srcDoc, "srcDoc", [[PDFDocument4, "PDFDocument"]]);
                   utils_1.assertIs(indices, "indices", [Array]);
                   return [4, srcDoc.flush()];
                 case 1:
@@ -20668,13 +20668,13 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.copy = function() {
+        PDFDocument4.prototype.copy = function() {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var pdfCopy, contentPages, idx, len;
             return tslib_1.__generator(this, function(_a) {
               switch (_a.label) {
                 case 0:
-                  return [4, PDFDocument3.create()];
+                  return [4, PDFDocument4.create()];
                 case 1:
                   pdfCopy = _a.sent();
                   return [4, pdfCopy.copyPages(this, this.getPageIndices())];
@@ -20710,7 +20710,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.addJavaScript = function(name, script) {
+        PDFDocument4.prototype.addJavaScript = function(name, script) {
           utils_1.assertIs(name, "name", ["string"]);
           utils_1.assertIs(script, "script", ["string"]);
           var embedder = JavaScriptEmbedder_1.default.for(script, name);
@@ -20718,7 +20718,7 @@ var require_PDFDocument = __commonJS({
           var javaScript = PDFJavaScript_1.default.of(ref, this, embedder);
           this.javaScripts.push(javaScript);
         };
-        PDFDocument3.prototype.attach = function(attachment, name, options) {
+        PDFDocument4.prototype.attach = function(attachment, name, options) {
           if (options === void 0) {
             options = {};
           }
@@ -20746,7 +20746,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedFont = function(font, options) {
+        PDFDocument4.prototype.embedFont = function(font, options) {
           if (options === void 0) {
             options = {};
           }
@@ -20789,7 +20789,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedStandardFont = function(font, customName) {
+        PDFDocument4.prototype.embedStandardFont = function(font, customName) {
           utils_1.assertIs(font, "font", ["string"]);
           if (!utils_1.isStandardFont(font)) {
             throw new TypeError("`font` must be one of type `StandardFonts`");
@@ -20800,7 +20800,7 @@ var require_PDFDocument = __commonJS({
           this.fonts.push(pdfFont);
           return pdfFont;
         };
-        PDFDocument3.prototype.embedJpg = function(jpg) {
+        PDFDocument4.prototype.embedJpg = function(jpg) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var bytes, embedder, ref, pdfImage;
             return tslib_1.__generator(this, function(_a) {
@@ -20819,7 +20819,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedPng = function(png) {
+        PDFDocument4.prototype.embedPng = function(png) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var bytes, embedder, ref, pdfImage;
             return tslib_1.__generator(this, function(_a) {
@@ -20838,7 +20838,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedPdf = function(pdf, indices) {
+        PDFDocument4.prototype.embedPdf = function(pdf, indices) {
           if (indices === void 0) {
             indices = [0];
           }
@@ -20851,14 +20851,14 @@ var require_PDFDocument = __commonJS({
                     "string",
                     Uint8Array,
                     ArrayBuffer,
-                    [PDFDocument3, "PDFDocument"]
+                    [PDFDocument4, "PDFDocument"]
                   ]);
                   utils_1.assertIs(indices, "indices", [Array]);
-                  if (!(pdf instanceof PDFDocument3)) return [3, 1];
+                  if (!(pdf instanceof PDFDocument4)) return [3, 1];
                   _a = pdf;
                   return [3, 3];
                 case 1:
-                  return [4, PDFDocument3.load(pdf)];
+                  return [4, PDFDocument4.load(pdf)];
                 case 2:
                   _a = _b.sent();
                   _b.label = 3;
@@ -20870,7 +20870,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedPage = function(page, boundingBox, transformationMatrix) {
+        PDFDocument4.prototype.embedPage = function(page, boundingBox, transformationMatrix) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var embeddedPage;
             return tslib_1.__generator(this, function(_a) {
@@ -20885,7 +20885,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.embedPages = function(pages, boundingBoxes, transformationMatrices) {
+        PDFDocument4.prototype.embedPages = function(pages, boundingBoxes, transformationMatrices) {
           if (boundingBoxes === void 0) {
             boundingBoxes = [];
           }
@@ -20935,7 +20935,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.flush = function() {
+        PDFDocument4.prototype.flush = function() {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             return tslib_1.__generator(this, function(_a) {
               switch (_a.label) {
@@ -20963,7 +20963,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.save = function(options) {
+        PDFDocument4.prototype.save = function(options) {
           if (options === void 0) {
             options = {};
           }
@@ -20993,7 +20993,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.saveAsBase64 = function(options) {
+        PDFDocument4.prototype.saveAsBase64 = function(options) {
           if (options === void 0) {
             options = {};
           }
@@ -21013,7 +21013,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.findPageForAnnotationRef = function(ref) {
+        PDFDocument4.prototype.findPageForAnnotationRef = function(ref) {
           var pages = this.getPages();
           for (var idx = 0, len = pages.length; idx < len; idx++) {
             var page = pages[idx];
@@ -21024,7 +21024,7 @@ var require_PDFDocument = __commonJS({
           }
           return void 0;
         };
-        PDFDocument3.prototype.embedAll = function(embeddables) {
+        PDFDocument4.prototype.embedAll = function(embeddables) {
           return tslib_1.__awaiter(this, void 0, void 0, function() {
             var idx, len;
             return tslib_1.__generator(this, function(_a) {
@@ -21050,7 +21050,7 @@ var require_PDFDocument = __commonJS({
             });
           });
         };
-        PDFDocument3.prototype.updateInfoDict = function() {
+        PDFDocument4.prototype.updateInfoDict = function() {
           var pdfLib = "pdf-lib (https://github.com/Hopding/pdf-lib)";
           var now = /* @__PURE__ */ new Date();
           var info = this.getInfoDict();
@@ -21061,7 +21061,7 @@ var require_PDFDocument = __commonJS({
           if (!info.get(core_1.PDFName.of("CreationDate")))
             this.setCreationDate(now);
         };
-        PDFDocument3.prototype.getInfoDict = function() {
+        PDFDocument4.prototype.getInfoDict = function() {
           var existingInfo = this.context.lookup(this.context.trailerInfo.Info);
           if (existingInfo instanceof core_1.PDFDict)
             return existingInfo;
@@ -21069,15 +21069,15 @@ var require_PDFDocument = __commonJS({
           this.context.trailerInfo.Info = this.context.register(newInfo);
           return newInfo;
         };
-        PDFDocument3.prototype.assertFontkit = function() {
+        PDFDocument4.prototype.assertFontkit = function() {
           if (!this.fontkit)
             throw new errors_1.FontkitNotRegisteredError();
           return this.fontkit;
         };
-        return PDFDocument3;
+        return PDFDocument4;
       })()
     );
-    exports2.default = PDFDocument2;
+    exports2.default = PDFDocument3;
     function assertIsLiteralOrHexString(pdfObject) {
       if (!(pdfObject instanceof core_1.PDFHexString) && !(pdfObject instanceof core_1.PDFString)) {
         throw new core_1.UnexpectedObjectTypeError([core_1.PDFHexString, core_1.PDFString], pdfObject);
@@ -22015,47 +22015,522 @@ var require_cjs = __commonJS({
   }
 });
 
+// packages/core/dist/document/pdf-encrypted.js
+var ENCRYPTED_PDF_MESSAGE, OWNER_ONLY_PDF_MESSAGE, PdfEncryptedError;
+var init_pdf_encrypted = __esm({
+  "packages/core/dist/document/pdf-encrypted.js"() {
+    "use strict";
+    ENCRYPTED_PDF_MESSAGE = "PDF is password-protected (encrypted); decrypt first: pdf-ops decrypt <in> <password> <out>";
+    OWNER_ONLY_PDF_MESSAGE = 'PDF is encrypted with an owner password only (it opens without a password, but cannot be edited encrypted); remove the encryption first: pdf-ops decrypt <in> "" <out>';
+    PdfEncryptedError = class extends Error {
+      constructor() {
+        super(ENCRYPTED_PDF_MESSAGE);
+        this.name = "PdfEncryptedError";
+      }
+    };
+  }
+});
+
+// packages/core/dist/document/pdf-extract.js
+var pdf_extract_exports = {};
+__export(pdf_extract_exports, {
+  analyzePdfDocument: () => analyzePdfDocument,
+  countVectorOperators: () => countVectorOperators,
+  decryptPdf: () => decryptPdf,
+  encryptPdf: () => encryptPdf,
+  extractPdfImages: () => extractPdfImages,
+  extractPdfTables: () => extractPdfTables,
+  extractPdfText: () => extractPdfText,
+  extractPdfTextLines: () => extractPdfTextLines,
+  pdfNeedsPassword: () => pdfNeedsPassword,
+  pngPixels: () => pngPixels,
+  renderPdfPages: () => renderPdfPages,
+  scanPdfSignals: () => scanPdfSignals,
+  textMathHint: () => textMathHint,
+  textTableHint: () => textTableHint
+});
+function loadMupdf() {
+  if (!_mupdf) {
+    const deps = process.env.TALOS_SKILL_DEPS;
+    const spec = deps ? (0, import_node_url.pathToFileURL)((0, import_node_path.join)(deps, "mupdf", "dist", "mupdf.js")).href : "mupdf";
+    _mupdf = import(spec);
+  }
+  return _mupdf;
+}
+function textMathHint(text) {
+  if (!text)
+    return false;
+  const hits = (text.match(MATH_CHARS) || []).length;
+  return hits >= 3 || hits / Math.max(text.length, 1) > 0.02;
+}
+function textTableHint(text) {
+  if (!text)
+    return false;
+  const gaps = (text.match(/ {2,}|\t/g) || []).length;
+  return gaps >= 6;
+}
+async function openDoc(bytes) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  if (doc.needsPassword())
+    throw new PdfEncryptedError();
+  if (doc.countPages() === 0) {
+    throw new Error("PDF has no readable pages (corrupt, encrypted, or empty)");
+  }
+  return { mupdf, doc };
+}
+async function analyzePdfDocument(bytes, options = {}) {
+  const wantText = options.text !== false;
+  const wantSignals = options.signals === true;
+  const { doc } = await openDoc(bytes);
+  const pageCount = doc.countPages();
+  const signals = [];
+  let out = "";
+  for (let i = 0; i < pageCount; i++) {
+    const page = doc.loadPage(i);
+    if (wantText) {
+      out += `
+[page ${i + 1}]
+${page.toStructuredText().asText()}`;
+    }
+    if (wantSignals) {
+      signals.push(pageSignalsFrom(page, i + 1));
+    }
+  }
+  return { text: wantText ? out.trim() : "", pageCount, signals };
+}
+async function extractPdfText(bytes) {
+  const { text, pageCount } = await analyzePdfDocument(bytes, { text: true });
+  return { text, pageCount };
+}
+function countVectorOperators(content) {
+  let ops = 0;
+  let curves = 0;
+  let fills = 0;
+  let i = 0;
+  const n = content.length;
+  while (i < n) {
+    const ch = content[i];
+    if (ch === "(") {
+      let depth = 1;
+      i++;
+      while (i < n && depth > 0) {
+        if (content[i] === "\\")
+          i++;
+        else if (content[i] === "(")
+          depth++;
+        else if (content[i] === ")")
+          depth--;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "<" && content[i + 1] !== "<") {
+      while (i < n && content[i] !== ">")
+        i++;
+      i++;
+      continue;
+    }
+    if (ch === "I" && content[i + 1] === "D" && isDelimiter(content[i + 2])) {
+      const end = content.indexOf("EI", i + 2);
+      i = end === -1 ? n : end + 2;
+      continue;
+    }
+    if (!isDelimiter(ch)) {
+      const start = i;
+      while (i < n && !isDelimiter(content[i]))
+        i++;
+      const token = content.slice(start, i);
+      switch (token) {
+        case "m":
+        case "l":
+        case "re":
+          ops++;
+          break;
+        case "c":
+        case "v":
+        case "y":
+          ops++;
+          curves++;
+          break;
+        case "f":
+        case "F":
+        case "f*":
+          fills++;
+          break;
+        case "B":
+        case "B*":
+        case "b":
+        case "b*":
+          fills++;
+          break;
+        default:
+          break;
+      }
+      continue;
+    }
+    i++;
+  }
+  return { ops, curves, fills };
+}
+function isDelimiter(ch) {
+  return ch === void 0 || ch === " " || ch === "\n" || ch === "\r" || ch === "	" || ch === "\f" || ch === "\0" || ch === "[" || ch === "]" || ch === "/" || ch === "{" || ch === "}";
+}
+function pageContentStream(page) {
+  try {
+    const obj = page.getObject?.();
+    const contents = obj?.get?.("Contents");
+    if (!contents)
+      return "";
+    const streams = contents.isArray?.() && contents.get ? Array.from({ length: contents.length ?? 0 }, (_, i) => contents.get(i)) : [contents];
+    let out = "";
+    for (const stream of streams) {
+      const buf = stream?.readStream?.();
+      const bytes = buf?.asUint8Array?.();
+      if (bytes)
+        out += Buffer.from(bytes).toString("latin1");
+    }
+    return out;
+  } catch {
+    return "";
+  }
+}
+function pageSignalsFrom(page, pageNumber) {
+  const json = JSON.parse(page.toStructuredText("preserve-images").asJSON());
+  const blocks = json.blocks ?? [];
+  const text = blocks.flatMap((b) => (b.lines ?? []).map((l) => l.text ?? "")).join(" ");
+  const [x0, y0, x1, y1] = page.getBounds();
+  const pageArea = Math.max((x1 - x0) * (y1 - y0), 1);
+  const imgArea = blocks.filter((b) => b.type === "image").reduce((a, b) => a + Math.max((b.bbox?.w ?? 0) * (b.bbox?.h ?? 0), 0), 0);
+  const vector = countVectorOperators(pageContentStream(page));
+  return {
+    page: pageNumber,
+    textChars: text.trim().length,
+    imageCoverage: Math.min(imgArea / pageArea, 1),
+    vectorOps: vector.ops,
+    vectorCurves: vector.curves,
+    vectorFills: vector.fills,
+    mathHint: textMathHint(text),
+    tableHint: textTableHint(text)
+  };
+}
+async function scanPdfSignals(bytes) {
+  const { signals } = await analyzePdfDocument(bytes, { text: false, signals: true });
+  return signals;
+}
+function median(nums) {
+  if (!nums.length)
+    return 0;
+  const s = [...nums].sort((a, b) => a - b);
+  return s[Math.floor(s.length / 2)];
+}
+async function extractPdfTables(bytes, pageNum, minColumns = 2) {
+  const { doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const from = pageNum ? pageNum : 1;
+  const to = pageNum ? pageNum : total;
+  const out = [];
+  for (let p = from; p <= to; p++) {
+    if (p < 1 || p > total)
+      continue;
+    const json = JSON.parse(doc.loadPage(p - 1).toStructuredText().asJSON());
+    const cells = [];
+    for (const b of json.blocks ?? []) {
+      if (b.type === "image")
+        continue;
+      for (const l of b.lines ?? []) {
+        const text = (l.text ?? "").trim();
+        if (!text)
+          continue;
+        cells.push({ text, x: l.bbox?.x ?? 0, y: l.bbox?.y ?? 0, h: l.bbox?.h ?? 12 });
+      }
+    }
+    if (cells.length < 2)
+      continue;
+    const medH = median(cells.map((c) => c.h)) || 12;
+    const rowTol = Math.max(4, medH * 0.6);
+    const colTol = Math.max(6, medH * 0.9);
+    const byY = [...cells].sort((a, b) => a.y - b.y);
+    const rowGroups = [];
+    let rowRef = Number.NEGATIVE_INFINITY;
+    for (const c of byY) {
+      if (c.y - rowRef > rowTol) {
+        rowGroups.push([]);
+        rowRef = c.y;
+      }
+      rowGroups[rowGroups.length - 1].push(c);
+    }
+    const colRefs = [];
+    for (const x of cells.map((c) => c.x).sort((a, b) => a - b)) {
+      if (!colRefs.length || x - colRefs[colRefs.length - 1] > colTol)
+        colRefs.push(x);
+    }
+    const colIndex = (x) => {
+      let best = 0, bd = Infinity;
+      colRefs.forEach((r, i) => {
+        const d = Math.abs(x - r);
+        if (d < bd) {
+          bd = d;
+          best = i;
+        }
+      });
+      return best;
+    };
+    const rows = [];
+    for (const group of rowGroups) {
+      const arr = Array(colRefs.length).fill("");
+      for (const c of group.sort((a, b) => a.x - b.x)) {
+        const i = colIndex(c.x);
+        arr[i] = arr[i] ? `${arr[i]} ${c.text}` : c.text;
+      }
+      if (arr.filter((v) => v).length >= minColumns)
+        rows.push(arr);
+    }
+    if (rows.length)
+      out.push({ page: p, rows });
+  }
+  return out;
+}
+async function extractPdfTextLines(bytes) {
+  const { doc } = await openDoc(bytes);
+  const out = [];
+  for (let p = 1; p <= doc.countPages(); p++) {
+    const page = doc.loadPage(p - 1);
+    const [x0, y0, x1, y1] = page.getBounds();
+    const json = JSON.parse(page.toStructuredText().asJSON());
+    const lines = [];
+    for (const b of json.blocks ?? []) {
+      if (b.type === "image")
+        continue;
+      for (const l of b.lines ?? []) {
+        const text = l.text ?? "";
+        if (!text.trim() || !l.bbox)
+          continue;
+        lines.push({
+          x: l.bbox.x ?? 0,
+          y: l.bbox.y ?? 0,
+          w: l.bbox.w ?? 0,
+          h: l.bbox.h ?? 0,
+          size: l.font?.size ?? 12,
+          text
+        });
+      }
+    }
+    out.push({ page: p, width: x1 - x0, height: y1 - y0, lines });
+  }
+  return out;
+}
+async function renderPdfPages(bytes, pages, scale = 2, maxEdge) {
+  const { mupdf, doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const wanted = pages === "all" ? Array.from({ length: total }, (_, i) => i + 1) : pages;
+  const out = [];
+  for (const p of wanted) {
+    if (p < 1 || p > total)
+      continue;
+    const page = doc.loadPage(p - 1);
+    const [x0, y0, x1, y1] = page.getBounds();
+    const longest = Math.max(x1 - x0, y1 - y0);
+    const s = maxEdge && longest > 0 ? Math.min(scale, maxEdge / longest) : scale;
+    const pix = page.toPixmap(mupdf.Matrix.scale(s, s), mupdf.ColorSpace.DeviceRGB, false, true);
+    out.push({ page: p, png: pix.asPNG() });
+  }
+  return out;
+}
+async function pngPixels(png) {
+  const mupdf = await loadMupdf();
+  const pix = new mupdf.Image(png).toPixmap();
+  const width = pix.getWidth(), height = pix.getHeight();
+  const channels = pix.getStride() / width;
+  return { width, height, channels, data: pix.getPixels() };
+}
+async function extractPdfImages(bytes, pages) {
+  const { doc } = await openDoc(bytes);
+  const total = doc.countPages();
+  const wanted = pages && pages.length ? pages : Array.from({ length: total }, (_, i) => i + 1);
+  const images = [];
+  let skipped = 0;
+  for (const p of wanted) {
+    if (p < 1 || p > total)
+      continue;
+    const stext = doc.loadPage(p - 1).toStructuredText("preserve-images");
+    let index = 0;
+    stext.walk({
+      onImageBlock(bbox, _matrix, image) {
+        const slot = index++;
+        try {
+          const png = image.toPixmap().asPNG();
+          images.push({
+            page: p,
+            index: slot,
+            bbox: [bbox[0], bbox[1], bbox[2], bbox[3]],
+            width: image.getWidth(),
+            height: image.getHeight(),
+            png
+          });
+        } catch {
+          skipped++;
+        }
+      }
+    });
+  }
+  return { images, skipped };
+}
+async function encryptPdf(bytes, userPassword, ownerPassword) {
+  if (!userPassword)
+    throw new Error("a non-empty user password is required");
+  const { doc } = await openDoc(bytes);
+  const opts = `encrypt=aes-256,user-password=${userPassword},owner-password=${ownerPassword || userPassword}`;
+  return doc.saveToBuffer(opts).asUint8Array();
+}
+async function pdfNeedsPassword(bytes) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  return doc.needsPassword();
+}
+async function decryptPdf(bytes, password) {
+  const mupdf = await loadMupdf();
+  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
+  if (doc.needsPassword()) {
+    if (doc.authenticatePassword(password) === 0)
+      throw new Error("wrong password");
+  }
+  if (doc.countPages() === 0)
+    throw new Error("PDF has no readable pages (corrupt or empty)");
+  return doc.saveToBuffer("encrypt=none").asUint8Array();
+}
+var import_node_path, import_node_url, _mupdf, MATH_CHARS;
+var init_pdf_extract = __esm({
+  "packages/core/dist/document/pdf-extract.js"() {
+    "use strict";
+    import_node_path = require("node:path");
+    import_node_url = require("node:url");
+    init_pdf_encrypted();
+    _mupdf = null;
+    MATH_CHARS = /[=∑∫√≤≥≠±∞πθλμσΩ×÷∂∇→←↔∈∉⊂⊃∀∃]/g;
+  }
+});
+
 // apps/admin/data/skills.lib/document/bin-src/pdf-ops.mjs
-var import_promises = require("node:fs/promises");
+var import_promises2 = require("node:fs/promises");
+var import_node_path3 = require("node:path");
 
 // packages/core/dist/document/pdf-ops.js
+var import_pdf_lib3 = __toESM(require_cjs(), 1);
+
+// packages/core/dist/document/pdf-lib-load.js
 var import_pdf_lib = __toESM(require_cjs(), 1);
+init_pdf_encrypted();
+var isEncryptedError = (e) => e instanceof import_pdf_lib.EncryptedPDFError || /PDFDocument\.load` is encrypted/.test(String(e?.message));
+async function loadEditablePdf(bytes) {
+  try {
+    return await import_pdf_lib.PDFDocument.load(bytes);
+  } catch (e) {
+    if (!isEncryptedError(e))
+      throw e;
+    const { pdfNeedsPassword: pdfNeedsPassword2 } = await Promise.resolve().then(() => (init_pdf_extract(), pdf_extract_exports));
+    const needsPassword = await pdfNeedsPassword2(bytes).catch(() => true);
+    throw needsPassword ? new PdfEncryptedError() : new Error(OWNER_ONLY_PDF_MESSAGE);
+  }
+}
+
+// packages/core/dist/document/pdf-text-font.js
+var import_promises = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+var import_pdf_lib2 = __toESM(require_cjs(), 1);
+async function loadFontkit() {
+  const mod = await import("./fontkit.cjs");
+  return mod.default?.create ? mod.default : mod;
+}
+var PDF_CJK_FONT_FILES = {
+  regular: "NotoSansSC-PDF-Regular.ttf",
+  bold: "NotoSansSC-PDF-Bold.ttf"
+};
+var LINE_BREAK = /\r\n|[\n\f\r\u000B\u0085\u2028\u2029]/;
+function encodableAs(std, text) {
+  const enc = import_pdf_lib2.StandardFontEmbedder.for(std);
+  try {
+    for (const line of text.replace(/\t/g, " ").split(LINE_BREAK))
+      enc.encodeText(line);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var codePoint = (cp) => `"${String.fromCodePoint(cp)}" (U+${cp.toString(16).toUpperCase().padStart(4, "0")})`;
+async function embedTextFont(doc, texts, opts = {}) {
+  const bold = opts.weight === "bold";
+  const std = bold ? import_pdf_lib2.StandardFonts.HelveticaBold : import_pdf_lib2.StandardFonts.Helvetica;
+  if (texts.every((t) => encodableAs(std, t)))
+    return doc.embedFont(std);
+  if (!opts.fontDir) {
+    const sample = [...texts.join("")].find((ch) => ch !== "	" && !LINE_BREAK.test(ch) && !encodableAs(std, ch)) ?? "";
+    throw new Error(`text has characters Helvetica cannot draw (e.g. ${codePoint(sample.codePointAt(0) ?? 0)}) and no CJK font directory was given`);
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (const t of texts) {
+    for (const ch of t) {
+      const cp = ch.codePointAt(0);
+      if (cp >= 32 && !LINE_BREAK.test(ch) && cp !== 127)
+        used.add(cp);
+    }
+  }
+  const fontkit = await loadFontkit();
+  const regularBytes = await (0, import_promises.readFile)((0, import_node_path2.join)(opts.fontDir, PDF_CJK_FONT_FILES.regular));
+  const regular = fontkit.create(regularBytes);
+  const missing = [...used].filter((cp) => !regular.hasGlyphForCodePoint(cp));
+  if (missing.length) {
+    const shown = missing.slice(0, 8).map(codePoint).join(", ");
+    throw new Error(`the bundled CJK font has no glyph for ${shown}${missing.length > 8 ? ` and ${missing.length - 8} more` : ""} \u2014 remove or replace those characters (it covers Chinese \u2014 all CJK Unified Ideographs \u2014 plus Latin, punctuation and full-width forms; emoji and rare extension characters are not included)`);
+  }
+  let bytes = regularBytes;
+  if (bold) {
+    const boldBytes = await (0, import_promises.readFile)((0, import_node_path2.join)(opts.fontDir, PDF_CJK_FONT_FILES.bold));
+    const boldFont = fontkit.create(boldBytes);
+    if ([...used].every((cp) => boldFont.hasGlyphForCodePoint(cp)))
+      bytes = boldBytes;
+  }
+  doc.registerFontkit(fontkit);
+  return doc.embedFont(bytes, { subset: true });
+}
+
+// packages/core/dist/document/pdf-ops.js
 async function mergePdfs(pdfs) {
   if (pdfs.length === 0)
     throw new Error("merge needs at least one input PDF");
-  const out = await import_pdf_lib.PDFDocument.create();
+  const out = await import_pdf_lib3.PDFDocument.create();
   for (const bytes of pdfs) {
-    const src = await import_pdf_lib.PDFDocument.load(bytes);
+    const src = await loadEditablePdf(bytes);
     const pages = await out.copyPages(src, src.getPageIndices());
     pages.forEach((p) => out.addPage(p));
   }
   return out.save();
 }
 async function splitPdf(bytes, from, to) {
-  const src = await import_pdf_lib.PDFDocument.load(bytes);
+  const src = await loadEditablePdf(bytes);
   const total = src.getPageCount();
   const idx = [];
   for (let p = Math.max(1, from); p <= Math.min(to, total); p++)
     idx.push(p - 1);
   if (!idx.length)
     throw new Error(`page range ${from}-${to} is empty (document has ${total} pages)`);
-  const out = await import_pdf_lib.PDFDocument.create();
+  const out = await import_pdf_lib3.PDFDocument.create();
   const pages = await out.copyPages(src, idx);
   pages.forEach((p) => out.addPage(p));
   return out.save();
 }
 async function rotatePdf(bytes, deg, pages) {
-  const doc = await import_pdf_lib.PDFDocument.load(bytes);
+  const doc = await loadEditablePdf(bytes);
   const all = doc.getPages();
   const targets = pages ? pages.map((p) => all[p - 1]).filter(Boolean) : all;
   for (const pg of targets) {
-    pg.setRotation((0, import_pdf_lib.degrees)(((pg.getRotation().angle + deg) % 360 + 360) % 360));
+    pg.setRotation((0, import_pdf_lib3.degrees)(((pg.getRotation().angle + deg) % 360 + 360) % 360));
   }
   return doc.save();
 }
-async function stampPdfText(bytes, stamps) {
-  const doc = await import_pdf_lib.PDFDocument.load(bytes);
-  const font = await doc.embedFont(import_pdf_lib.StandardFonts.Helvetica);
+async function stampPdfText(bytes, stamps, opts = {}) {
+  const doc = await loadEditablePdf(bytes);
+  const font = await embedTextFont(doc, stamps.map((s) => String(s.text)), opts);
   const pages = doc.getPages();
   let stamped = 0;
   for (const s of stamps) {
@@ -22063,76 +22538,44 @@ async function stampPdfText(bytes, stamps) {
     if (!pg)
       continue;
     const g = s.grey ?? 0;
-    pg.drawText(String(s.text), { x: s.x, y: s.y, size: s.size ?? 11, font, color: (0, import_pdf_lib.rgb)(g, g, g) });
+    pg.drawText(String(s.text), { x: s.x, y: s.y, size: s.size ?? 11, font, color: (0, import_pdf_lib3.rgb)(g, g, g) });
     stamped++;
   }
   return { bytes: await doc.save(), stamped };
 }
-async function watermarkPdf(bytes, text) {
-  const doc = await import_pdf_lib.PDFDocument.load(bytes);
-  const font = await doc.embedFont(import_pdf_lib.StandardFonts.HelveticaBold);
+async function watermarkPdf(bytes, text, opts = {}) {
+  const doc = await loadEditablePdf(bytes);
+  const font = await embedTextFont(doc, [text], { ...opts, weight: "bold" });
   const size = 48;
+  const angle = Math.PI / 4;
+  const halfW = font.widthOfTextAtSize(text, size) / 2;
+  const halfH = font.heightAtSize(size, { descender: false }) / 2;
+  const dx = halfW * Math.cos(angle) - halfH * Math.sin(angle);
+  const dy = halfW * Math.sin(angle) + halfH * Math.cos(angle);
   for (const pg of doc.getPages()) {
-    const { width, height } = pg.getSize();
+    const box = pg.getMediaBox();
     pg.drawText(text, {
-      x: width / 2 - text.length * size / 4,
-      y: height / 2,
+      x: box.x + box.width / 2 - dx,
+      y: box.y + box.height / 2 - dy,
       size,
       font,
-      color: (0, import_pdf_lib.rgb)(0.6, 0.6, 0.6),
+      color: (0, import_pdf_lib3.rgb)(0.6, 0.6, 0.6),
       opacity: 0.3,
-      rotate: (0, import_pdf_lib.degrees)(45)
+      rotate: (0, import_pdf_lib3.degrees)(45)
     });
   }
   return doc.save();
 }
 
-// packages/core/dist/document/pdf-extract.js
-var import_node_path = require("node:path");
-var import_node_url = require("node:url");
-var _mupdf = null;
-function loadMupdf() {
-  if (!_mupdf) {
-    const deps = process.env.TALOS_SKILL_DEPS;
-    const spec = deps ? (0, import_node_url.pathToFileURL)((0, import_node_path.join)(deps, "mupdf", "dist", "mupdf.js")).href : "mupdf";
-    _mupdf = import(spec);
-  }
-  return _mupdf;
-}
-async function openDoc(bytes) {
-  const mupdf = await loadMupdf();
-  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
-  if (doc.countPages() === 0) {
-    throw new Error("PDF has no readable pages (corrupt, encrypted, or empty)");
-  }
-  return { mupdf, doc };
-}
-async function encryptPdf(bytes, userPassword, ownerPassword) {
-  if (!userPassword)
-    throw new Error("a non-empty user password is required");
-  const { doc } = await openDoc(bytes);
-  const opts = `encrypt=aes-256,user-password=${userPassword},owner-password=${ownerPassword || userPassword}`;
-  return doc.saveToBuffer(opts).asUint8Array();
-}
-async function decryptPdf(bytes, password) {
-  const mupdf = await loadMupdf();
-  const doc = mupdf.Document.openDocument(bytes, "application/pdf");
-  if (doc.needsPassword()) {
-    if (doc.authenticatePassword(password) === 0)
-      throw new Error("wrong password");
-  }
-  if (doc.countPages() === 0)
-    throw new Error("PDF has no readable pages (corrupt or empty)");
-  return doc.saveToBuffer("encrypt=none").asUint8Array();
-}
-
 // apps/admin/data/skills.lib/document/bin-src/pdf-ops.mjs
+init_pdf_extract();
+var fontDir = (0, import_node_path3.join)(__dirname, "..", "assets", "pdf-fonts");
 function die(msg, code = 1) {
   process.stderr.write(`pdf-ops: ${msg}
 `);
   process.exit(code);
 }
-var load = async (p) => new Uint8Array(await (0, import_promises.readFile)(p).catch((e) => die(`cannot read ${p}: ${e.message}`)));
+var load = async (p) => new Uint8Array(await (0, import_promises2.readFile)(p).catch((e) => die(`cannot read ${p}: ${e.message}`)));
 function parsePages(spec) {
   const out = [];
   for (const part of spec.split(",")) {
@@ -22151,7 +22594,7 @@ async function main() {
       const [out, ...ins] = rest;
       if (!out || ins.length < 1) die("usage: pdf-ops merge <out.pdf> <in1.pdf> ...", 64);
       const bytes = await mergePdfs(await Promise.all(ins.map(load)));
-      await (0, import_promises.writeFile)(out, Buffer.from(bytes));
+      await (0, import_promises2.writeFile)(out, Buffer.from(bytes));
       process.stdout.write(`merged ${ins.length} \u2192 ${out}
 `);
       return;
@@ -22161,7 +22604,7 @@ async function main() {
       if (!inPdf || !range || !out) die("usage: pdf-ops split <in.pdf> <from-to> <out.pdf>", 64);
       const m = /^(\d+)-(\d+)$/.exec(range) || die(`bad range: ${range} (use from-to)`, 64);
       const bytes = await splitPdf(await load(inPdf), Number(m[1]), Number(m[2]));
-      await (0, import_promises.writeFile)(out, Buffer.from(bytes));
+      await (0, import_promises2.writeFile)(out, Buffer.from(bytes));
       process.stdout.write(`wrote ${out}
 `);
       return;
@@ -22170,7 +22613,7 @@ async function main() {
       const [inPdf, deg, out, pages] = rest;
       if (!inPdf || !deg || !out) die("usage: pdf-ops rotate <in.pdf> <deg> <out.pdf> [pages]", 64);
       const bytes = await rotatePdf(await load(inPdf), Number(deg), pages ? parsePages(pages) : void 0);
-      await (0, import_promises.writeFile)(out, Buffer.from(bytes));
+      await (0, import_promises2.writeFile)(out, Buffer.from(bytes));
       process.stdout.write(`wrote ${out}
 `);
       return;
@@ -22178,8 +22621,8 @@ async function main() {
     if (mode === "watermark") {
       const [inPdf, text, out] = rest;
       if (!inPdf || !text || !out) die("usage: pdf-ops watermark <in.pdf> <text> <out.pdf>", 64);
-      const bytes = await watermarkPdf(await load(inPdf), text);
-      await (0, import_promises.writeFile)(out, Buffer.from(bytes));
+      const bytes = await watermarkPdf(await load(inPdf), text, { fontDir });
+      await (0, import_promises2.writeFile)(out, Buffer.from(bytes));
       process.stdout.write(`wrote ${out}
 `);
       return;
@@ -22189,13 +22632,13 @@ async function main() {
       if (!inPdf || !stampsPath || !out) die("usage: pdf-ops stamp <in.pdf> <stamps.json> <out.pdf>", 64);
       let stamps;
       try {
-        stamps = JSON.parse(await (0, import_promises.readFile)(stampsPath, "utf8"));
+        stamps = JSON.parse(await (0, import_promises2.readFile)(stampsPath, "utf8"));
       } catch (e) {
         die(`bad stamps json: ${e.message}`, 64);
       }
       if (!Array.isArray(stamps)) die("stamps json must be an array of {page,x,y,text}", 64);
-      const r = await stampPdfText(await load(inPdf), stamps);
-      await (0, import_promises.writeFile)(out, Buffer.from(r.bytes));
+      const r = await stampPdfText(await load(inPdf), stamps, { fontDir });
+      await (0, import_promises2.writeFile)(out, Buffer.from(r.bytes));
       process.stdout.write(JSON.stringify({ ok: true, out, stamped: r.stamped }) + "\n");
       return;
     }
@@ -22203,15 +22646,15 @@ async function main() {
       const [inPdf, out, userPw, ownerPw] = rest;
       if (!inPdf || !out || !userPw) die("usage: pdf-ops encrypt <in.pdf> <out.pdf> <user-password> [owner-password]", 64);
       const bytes = await encryptPdf(await load(inPdf), userPw, ownerPw);
-      await (0, import_promises.writeFile)(out, Buffer.from(bytes));
+      await (0, import_promises2.writeFile)(out, Buffer.from(bytes));
       process.stdout.write(JSON.stringify({ ok: true, out, encryption: "aes-256" }) + "\n");
       return;
     }
     if (mode === "decrypt") {
       const [inPdf, pw, out] = rest;
-      if (!inPdf || !pw || !out) die("usage: pdf-ops decrypt <in.pdf> <password> <out.pdf>", 64);
+      if (!inPdf || pw === void 0 || !out) die("usage: pdf-ops decrypt <in.pdf> <password> <out.pdf>", 64);
       const bytes = await decryptPdf(await load(inPdf), pw);
-      await (0, import_promises.writeFile)(out, Buffer.from(bytes));
+      await (0, import_promises2.writeFile)(out, Buffer.from(bytes));
       process.stdout.write(JSON.stringify({ ok: true, out, encryption: "none" }) + "\n");
       return;
     }