@taloswork/ose-shared 0.1.10 → 0.1.12

package/skills/document/bin/pdf-form.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);
             }
@@ -6416,39 +6416,39 @@ var require_PDFArray = __commonJS({
     var PDFObject_1 = tslib_1.__importDefault(require_PDFObject());
     var CharCodes_1 = tslib_1.__importDefault(require_CharCodes());
     var errors_1 = require_errors2();
-    var PDFArray = (
+    var PDFArray2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(PDFArray2, _super);
-        function PDFArray2(context) {
+        tslib_1.__extends(PDFArray3, _super);
+        function PDFArray3(context) {
           var _this = _super.call(this) || this;
           _this.array = [];
           _this.context = context;
           return _this;
         }
-        PDFArray2.prototype.size = function() {
+        PDFArray3.prototype.size = function() {
           return this.array.length;
         };
-        PDFArray2.prototype.push = function(object) {
+        PDFArray3.prototype.push = function(object) {
           this.array.push(object);
         };
-        PDFArray2.prototype.insert = function(index, object) {
+        PDFArray3.prototype.insert = function(index, object) {
           this.array.splice(index, 0, object);
         };
-        PDFArray2.prototype.indexOf = function(object) {
+        PDFArray3.prototype.indexOf = function(object) {
           var index = this.array.indexOf(object);
           return index === -1 ? void 0 : index;
         };
-        PDFArray2.prototype.remove = function(index) {
+        PDFArray3.prototype.remove = function(index) {
           this.array.splice(index, 1);
         };
-        PDFArray2.prototype.set = function(idx, object) {
+        PDFArray3.prototype.set = function(idx, object) {
           this.array[idx] = object;
         };
-        PDFArray2.prototype.get = function(index) {
+        PDFArray3.prototype.get = function(index) {
           return this.array[index];
         };
-        PDFArray2.prototype.lookupMaybe = function(index) {
+        PDFArray3.prototype.lookupMaybe = function(index) {
           var _a;
           var types = [];
           for (var _i = 1; _i < arguments.length; _i++) {
@@ -6456,7 +6456,7 @@ var require_PDFArray = __commonJS({
           }
           return (_a = this.context).lookupMaybe.apply(_a, tslib_1.__spreadArrays([this.get(index)], types));
         };
-        PDFArray2.prototype.lookup = function(index) {
+        PDFArray3.prototype.lookup = function(index) {
           var _a;
           var types = [];
           for (var _i = 1; _i < arguments.length; _i++) {
@@ -6464,7 +6464,7 @@ var require_PDFArray = __commonJS({
           }
           return (_a = this.context).lookup.apply(_a, tslib_1.__spreadArrays([this.get(index)], types));
         };
-        PDFArray2.prototype.asRectangle = function() {
+        PDFArray3.prototype.asRectangle = function() {
           if (this.size() !== 4)
             throw new errors_1.PDFArrayIsNotRectangleError(this.size());
           var lowerLeftX = this.lookup(0, PDFNumber_1.default).asNumber();
@@ -6477,17 +6477,17 @@ var require_PDFArray = __commonJS({
           var height = upperRightY - lowerLeftY;
           return { x, y, width, height };
         };
-        PDFArray2.prototype.asArray = function() {
+        PDFArray3.prototype.asArray = function() {
           return this.array.slice();
         };
-        PDFArray2.prototype.clone = function(context) {
-          var clone = PDFArray2.withContext(context || this.context);
+        PDFArray3.prototype.clone = function(context) {
+          var clone = PDFArray3.withContext(context || this.context);
           for (var idx = 0, len = this.size(); idx < len; idx++) {
             clone.push(this.array[idx]);
           }
           return clone;
         };
-        PDFArray2.prototype.toString = function() {
+        PDFArray3.prototype.toString = function() {
           var arrayString = "[ ";
           for (var idx = 0, len = this.size(); idx < len; idx++) {
             arrayString += this.get(idx).toString();
@@ -6496,14 +6496,14 @@ var require_PDFArray = __commonJS({
           arrayString += "]";
           return arrayString;
         };
-        PDFArray2.prototype.sizeInBytes = function() {
+        PDFArray3.prototype.sizeInBytes = function() {
           var size = 3;
           for (var idx = 0, len = this.size(); idx < len; idx++) {
             size += this.get(idx).sizeInBytes() + 1;
           }
           return size;
         };
-        PDFArray2.prototype.copyBytesInto = function(buffer, offset) {
+        PDFArray3.prototype.copyBytesInto = function(buffer, offset) {
           var initialOffset = offset;
           buffer[offset++] = CharCodes_1.default.LeftSquareBracket;
           buffer[offset++] = CharCodes_1.default.Space;
@@ -6514,7 +6514,7 @@ var require_PDFArray = __commonJS({
           buffer[offset++] = CharCodes_1.default.RightSquareBracket;
           return offset - initialOffset;
         };
-        PDFArray2.prototype.scalePDFNumbers = function(x, y) {
+        PDFArray3.prototype.scalePDFNumbers = function(x, y) {
           for (var idx = 0, len = this.size(); idx < len; idx++) {
             var el = this.lookup(idx);
             if (el instanceof PDFNumber_1.default) {
@@ -6523,13 +6523,13 @@ var require_PDFArray = __commonJS({
             }
           }
         };
-        PDFArray2.withContext = function(context) {
-          return new PDFArray2(context);
+        PDFArray3.withContext = function(context) {
+          return new PDFArray3(context);
         };
-        return PDFArray2;
+        return PDFArray3;
       })(PDFObject_1.default)
     );
-    exports2.default = PDFArray;
+    exports2.default = PDFArray2;
   }
 });
 
@@ -6673,11 +6673,11 @@ var require_PDFName = __commonJS({
     };
     var ENFORCER = {};
     var pool = /* @__PURE__ */ new Map();
-    var PDFName = (
+    var PDFName2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(PDFName2, _super);
-        function PDFName2(enforcer, name) {
+        tslib_1.__extends(PDFName3, _super);
+        function PDFName3(enforcer, name) {
           var _this = this;
           if (enforcer !== ENFORCER)
             throw new errors_1.PrivateConstructorError("PDFName");
@@ -6691,7 +6691,7 @@ var require_PDFName = __commonJS({
           _this.encodedName = encodedName;
           return _this;
         }
-        PDFName2.prototype.asBytes = function() {
+        PDFName3.prototype.asBytes = function() {
           var bytes = [];
           var hex = "";
           var escaped = false;
@@ -6723,67 +6723,67 @@ var require_PDFName = __commonJS({
           }
           return new Uint8Array(bytes);
         };
-        PDFName2.prototype.decodeText = function() {
+        PDFName3.prototype.decodeText = function() {
           var bytes = this.asBytes();
           return String.fromCharCode.apply(String, Array.from(bytes));
         };
-        PDFName2.prototype.asString = function() {
+        PDFName3.prototype.asString = function() {
           return this.encodedName;
         };
-        PDFName2.prototype.value = function() {
+        PDFName3.prototype.value = function() {
           return this.encodedName;
         };
-        PDFName2.prototype.clone = function() {
+        PDFName3.prototype.clone = function() {
           return this;
         };
-        PDFName2.prototype.toString = function() {
+        PDFName3.prototype.toString = function() {
           return this.encodedName;
         };
-        PDFName2.prototype.sizeInBytes = function() {
+        PDFName3.prototype.sizeInBytes = function() {
           return this.encodedName.length;
         };
-        PDFName2.prototype.copyBytesInto = function(buffer, offset) {
+        PDFName3.prototype.copyBytesInto = function(buffer, offset) {
           offset += utils_1.copyStringIntoBuffer(this.encodedName, buffer, offset);
           return this.encodedName.length;
         };
-        PDFName2.of = function(name) {
+        PDFName3.of = function(name) {
           var decodedValue = decodeName(name);
           var instance = pool.get(decodedValue);
           if (!instance) {
-            instance = new PDFName2(ENFORCER, decodedValue);
+            instance = new PDFName3(ENFORCER, decodedValue);
             pool.set(decodedValue, instance);
           }
           return instance;
         };
-        PDFName2.Length = PDFName2.of("Length");
-        PDFName2.FlateDecode = PDFName2.of("FlateDecode");
-        PDFName2.Resources = PDFName2.of("Resources");
-        PDFName2.Font = PDFName2.of("Font");
-        PDFName2.XObject = PDFName2.of("XObject");
-        PDFName2.ExtGState = PDFName2.of("ExtGState");
-        PDFName2.Contents = PDFName2.of("Contents");
-        PDFName2.Type = PDFName2.of("Type");
-        PDFName2.Parent = PDFName2.of("Parent");
-        PDFName2.MediaBox = PDFName2.of("MediaBox");
-        PDFName2.Page = PDFName2.of("Page");
-        PDFName2.Annots = PDFName2.of("Annots");
-        PDFName2.TrimBox = PDFName2.of("TrimBox");
-        PDFName2.ArtBox = PDFName2.of("ArtBox");
-        PDFName2.BleedBox = PDFName2.of("BleedBox");
-        PDFName2.CropBox = PDFName2.of("CropBox");
-        PDFName2.Rotate = PDFName2.of("Rotate");
-        PDFName2.Title = PDFName2.of("Title");
-        PDFName2.Author = PDFName2.of("Author");
-        PDFName2.Subject = PDFName2.of("Subject");
-        PDFName2.Creator = PDFName2.of("Creator");
-        PDFName2.Keywords = PDFName2.of("Keywords");
-        PDFName2.Producer = PDFName2.of("Producer");
-        PDFName2.CreationDate = PDFName2.of("CreationDate");
-        PDFName2.ModDate = PDFName2.of("ModDate");
-        return PDFName2;
+        PDFName3.Length = PDFName3.of("Length");
+        PDFName3.FlateDecode = PDFName3.of("FlateDecode");
+        PDFName3.Resources = PDFName3.of("Resources");
+        PDFName3.Font = PDFName3.of("Font");
+        PDFName3.XObject = PDFName3.of("XObject");
+        PDFName3.ExtGState = PDFName3.of("ExtGState");
+        PDFName3.Contents = PDFName3.of("Contents");
+        PDFName3.Type = PDFName3.of("Type");
+        PDFName3.Parent = PDFName3.of("Parent");
+        PDFName3.MediaBox = PDFName3.of("MediaBox");
+        PDFName3.Page = PDFName3.of("Page");
+        PDFName3.Annots = PDFName3.of("Annots");
+        PDFName3.TrimBox = PDFName3.of("TrimBox");
+        PDFName3.ArtBox = PDFName3.of("ArtBox");
+        PDFName3.BleedBox = PDFName3.of("BleedBox");
+        PDFName3.CropBox = PDFName3.of("CropBox");
+        PDFName3.Rotate = PDFName3.of("Rotate");
+        PDFName3.Title = PDFName3.of("Title");
+        PDFName3.Author = PDFName3.of("Author");
+        PDFName3.Subject = PDFName3.of("Subject");
+        PDFName3.Creator = PDFName3.of("Creator");
+        PDFName3.Keywords = PDFName3.of("Keywords");
+        PDFName3.Producer = PDFName3.of("Producer");
+        PDFName3.CreationDate = PDFName3.of("CreationDate");
+        PDFName3.ModDate = PDFName3.of("ModDate");
+        return PDFName3;
       })(PDFObject_1.default)
     );
-    exports2.default = PDFName;
+    exports2.default = PDFName2;
   }
 });
 
@@ -7108,11 +7108,11 @@ var require_PDFRef = __commonJS({
     var utils_1 = require_utils2();
     var ENFORCER = {};
     var pool = /* @__PURE__ */ new Map();
-    var PDFRef = (
+    var PDFRef2 = (
       /** @class */
       (function(_super) {
-        tslib_1.__extends(PDFRef2, _super);
-        function PDFRef2(enforcer, objectNumber, generationNumber) {
+        tslib_1.__extends(PDFRef3, _super);
+        function PDFRef3(enforcer, objectNumber, generationNumber) {
           var _this = this;
           if (enforcer !== ENFORCER)
             throw new errors_1.PrivateConstructorError("PDFRef");
@@ -7122,35 +7122,35 @@ var require_PDFRef = __commonJS({
           _this.tag = objectNumber + " " + generationNumber + " R";
           return _this;
         }
-        PDFRef2.prototype.clone = function() {
+        PDFRef3.prototype.clone = function() {
           return this;
         };
-        PDFRef2.prototype.toString = function() {
+        PDFRef3.prototype.toString = function() {
           return this.tag;
         };
-        PDFRef2.prototype.sizeInBytes = function() {
+        PDFRef3.prototype.sizeInBytes = function() {
           return this.tag.length;
         };
-        PDFRef2.prototype.copyBytesInto = function(buffer, offset) {
+        PDFRef3.prototype.copyBytesInto = function(buffer, offset) {
           offset += utils_1.copyStringIntoBuffer(this.tag, buffer, offset);
           return this.tag.length;
         };
-        PDFRef2.of = function(objectNumber, generationNumber) {
+        PDFRef3.of = function(objectNumber, generationNumber) {
           if (generationNumber === void 0) {
             generationNumber = 0;
           }
           var tag = objectNumber + " " + generationNumber + " R";
           var instance = pool.get(tag);
           if (!instance) {
-            instance = new PDFRef2(ENFORCER, objectNumber, generationNumber);
+            instance = new PDFRef3(ENFORCER, objectNumber, generationNumber);
             pool.set(tag, instance);
           }
           return instance;
         };
-        return PDFRef2;
+        return PDFRef3;
       })(PDFObject_1.default)
     );
-    exports2.default = PDFRef;
+    exports2.default = PDFRef2;
   }
 });
 
@@ -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) {
@@ -19729,23 +19729,23 @@ var require_StandardFonts = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.StandardFonts = void 0;
-    var StandardFonts;
-    (function(StandardFonts2) {
-      StandardFonts2["Courier"] = "Courier";
-      StandardFonts2["CourierBold"] = "Courier-Bold";
-      StandardFonts2["CourierOblique"] = "Courier-Oblique";
-      StandardFonts2["CourierBoldOblique"] = "Courier-BoldOblique";
-      StandardFonts2["Helvetica"] = "Helvetica";
-      StandardFonts2["HelveticaBold"] = "Helvetica-Bold";
-      StandardFonts2["HelveticaOblique"] = "Helvetica-Oblique";
-      StandardFonts2["HelveticaBoldOblique"] = "Helvetica-BoldOblique";
-      StandardFonts2["TimesRoman"] = "Times-Roman";
-      StandardFonts2["TimesRomanBold"] = "Times-Bold";
-      StandardFonts2["TimesRomanItalic"] = "Times-Italic";
-      StandardFonts2["TimesRomanBoldItalic"] = "Times-BoldItalic";
-      StandardFonts2["Symbol"] = "Symbol";
-      StandardFonts2["ZapfDingbats"] = "ZapfDingbats";
-    })(StandardFonts = exports2.StandardFonts || (exports2.StandardFonts = {}));
+    var StandardFonts2;
+    (function(StandardFonts3) {
+      StandardFonts3["Courier"] = "Courier";
+      StandardFonts3["CourierBold"] = "Courier-Bold";
+      StandardFonts3["CourierOblique"] = "Courier-Oblique";
+      StandardFonts3["CourierBoldOblique"] = "Courier-BoldOblique";
+      StandardFonts3["Helvetica"] = "Helvetica";
+      StandardFonts3["HelveticaBold"] = "Helvetica-Bold";
+      StandardFonts3["HelveticaOblique"] = "Helvetica-Oblique";
+      StandardFonts3["HelveticaBoldOblique"] = "Helvetica-BoldOblique";
+      StandardFonts3["TimesRoman"] = "Times-Roman";
+      StandardFonts3["TimesRomanBold"] = "Times-Bold";
+      StandardFonts3["TimesRomanItalic"] = "Times-Italic";
+      StandardFonts3["TimesRomanBoldItalic"] = "Times-BoldItalic";
+      StandardFonts3["Symbol"] = "Symbol";
+      StandardFonts3["ZapfDingbats"] = "ZapfDingbats";
+    })(StandardFonts2 = exports2.StandardFonts || (exports2.StandardFonts = {}));
   }
 });
 
@@ -22015,20 +22015,490 @@ 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,
+  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 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-form.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-form.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;
+  }
+}
+function isWinAnsiText(texts) {
+  return texts.every((t) => encodableAs(import_pdf_lib2.StandardFonts.Helvetica, t));
+}
+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-form.js
 function fieldType(f) {
   return f.constructor.name.replace(/^PDF/, "").replace(/\d+$/, "");
 }
 async function listPdfFormFields(bytes) {
-  const doc = await import_pdf_lib.PDFDocument.load(bytes);
+  const doc = await loadEditablePdf(bytes);
   return doc.getForm().getFields().map((f) => ({ name: f.getName(), type: fieldType(f) }));
 }
 async function fillPdfForm(bytes, values, opts = {}) {
-  const doc = await import_pdf_lib.PDFDocument.load(bytes);
+  const doc = await loadEditablePdf(bytes);
   const form = doc.getForm();
   const filled = [];
   const skipped = [];
@@ -22060,12 +22530,38 @@ async function fillPdfForm(bytes, values, opts = {}) {
     }
     (ok ? filled : skipped).push(name);
   }
-  if (opts.flatten)
-    form.flatten();
+  const texts = form.getFields().filter((f) => f.needsAppearancesUpdate()).flatMap(fieldTexts);
+  const cjk = !isWinAnsiText(texts);
+  if (cjk)
+    form.updateFieldAppearances(await embedTextFont(doc, texts, opts));
+  if (opts.flatten) {
+    form.flatten({ updateFieldAppearances: !cjk });
+    dropDanglingAnnots(doc);
+  }
   return { bytes: await doc.save(), filled, skipped };
 }
+function fieldTexts(field) {
+  const f = field;
+  if (typeof f.getText === "function")
+    return [f.getText() ?? ""];
+  const sel = typeof f.getSelected === "function" ? f.getSelected() : void 0;
+  return Array.isArray(sel) ? sel : [];
+}
+function dropDanglingAnnots(doc) {
+  for (const page of doc.getPages()) {
+    const raw = page.node.get(import_pdf_lib3.PDFName.of("Annots"));
+    const annots = raw instanceof import_pdf_lib3.PDFRef ? doc.context.lookup(raw) : raw;
+    if (!(annots instanceof import_pdf_lib3.PDFArray))
+      continue;
+    for (let i = annots.size() - 1; i >= 0; i--) {
+      const ref = annots.get(i);
+      if (ref instanceof import_pdf_lib3.PDFRef && doc.context.lookup(ref) === void 0)
+        annots.remove(i);
+    }
+  }
+}
 async function overlayPdfFormBoxes(bytes) {
-  const doc = await import_pdf_lib.PDFDocument.load(bytes);
+  const doc = await loadEditablePdf(bytes);
   const pages = doc.getPages();
   let boxes = 0;
   for (const field of doc.getForm().getFields()) {
@@ -22078,7 +22574,7 @@ async function overlayPdfFormBoxes(bytes) {
         y: rect.y,
         width: rect.width,
         height: rect.height,
-        borderColor: (0, import_pdf_lib.rgb)(1, 0, 0),
+        borderColor: (0, import_pdf_lib3.rgb)(1, 0, 0),
         borderWidth: 1.5,
         opacity: 0,
         borderOpacity: 1
@@ -22092,6 +22588,7 @@ async function overlayPdfFormBoxes(bytes) {
 }
 
 // apps/admin/data/skills.lib/document/bin-src/pdf-form.mjs
+var fontDir = (0, import_node_path3.join)(__dirname, "..", "assets", "pdf-fonts");
 function die(msg, code = 1) {
   process.stderr.write(`pdf-form: ${msg}
 `);
@@ -22104,7 +22601,7 @@ async function main() {
     if (!inPdf) die("usage: pdf-form list <in.pdf>", 64);
     let raw;
     try {
-      raw = await (0, import_promises.readFile)(inPdf);
+      raw = await (0, import_promises2.readFile)(inPdf);
     } catch (e) {
       die(`cannot read ${inPdf}: ${e.message}`);
     }
@@ -22122,36 +22619,36 @@ async function main() {
     if (!inPdf || !valuesPath || !outPdf) die("usage: pdf-form fill <in.pdf> <values.json> <out.pdf> [--flatten]", 64);
     let raw, values;
     try {
-      raw = await (0, import_promises.readFile)(inPdf);
+      raw = await (0, import_promises2.readFile)(inPdf);
     } catch (e) {
       die(`cannot read ${inPdf}: ${e.message}`);
     }
     try {
-      values = JSON.parse(await (0, import_promises.readFile)(valuesPath, "utf-8"));
+      values = JSON.parse(await (0, import_promises2.readFile)(valuesPath, "utf-8"));
     } catch (e) {
       die(`bad values json: ${e.message}`, 64);
     }
     let result;
     try {
-      result = await fillPdfForm(new Uint8Array(raw), values, { flatten: flag === "--flatten" });
+      result = await fillPdfForm(new Uint8Array(raw), values, { flatten: flag === "--flatten", fontDir });
     } catch (e) {
       die(`fill failed: ${e.message}`);
     }
-    await (0, import_promises.writeFile)(outPdf, Buffer.from(result.bytes));
+    await (0, import_promises2.writeFile)(outPdf, Buffer.from(result.bytes));
     process.stdout.write(JSON.stringify({ out: outPdf, filled: result.filled, skipped: result.skipped }, null, 2) + "\n");
     return;
   }
   if (mode === "overlay") {
     const [inPdf, out] = rest;
     if (!inPdf || !out) die("usage: pdf-form overlay <filled.pdf> <out.pdf>  (then pdf-render + LOOK)", 64);
-    const bytes = new Uint8Array(await (0, import_promises.readFile)(inPdf).catch((e) => die(`cannot read ${inPdf}: ${e.message}`)));
+    const bytes = new Uint8Array(await (0, import_promises2.readFile)(inPdf).catch((e) => die(`cannot read ${inPdf}: ${e.message}`)));
     let r;
     try {
       r = await overlayPdfFormBoxes(bytes);
     } catch (e) {
       die(e.message);
     }
-    await (0, import_promises.writeFile)(out, Buffer.from(r.bytes));
+    await (0, import_promises2.writeFile)(out, Buffer.from(r.bytes));
     process.stdout.write(JSON.stringify({ ok: true, out, boxes: r.boxes }) + "\n");
     process.stderr.write("pdf-form: now pdf-render the page(s) and VISUALLY CHECK every value sits inside its red box\n");
     return;