@breakside/jskit 2026.10.0 → 2026.26.0

package/Root/Frameworks/Foundation/JSTextTypesetter.js

@@ -77,9 +77,14 @@ JSClass("JSTextTypesetter", JSObject, {
         var attributes = this._attributedString.attributesAtIndex(range.location);
         attributes = this.resolveAttributes(attributes);
         var font = attributes.font;
+        if (this.useDisplayMetrics){
+            return JSTextLine.initWithHeight(font.displayLineHeight, -font.displayDescender, range.location);
+        }
         return JSTextLine.initWithHeight(font.lineHeight, -font.descender, range.location);
     },
 
+    useDisplayMetrics: false,
+
     _createLineFromLayout: function(layout){
         // Create runs from the adjusted run descriptors
         var runs = [];
@@ -88,7 +93,7 @@ JSClass("JSTextTypesetter", JSObject, {
         var runDescriptor;
         for (var i = 0, l = layout.runDescriptors.length; i < l; ++i){
             runDescriptor = layout.runDescriptors[i];
-            run = JSTextRun.initWithGlyphs(runDescriptor.glyphs, runDescriptor.glyphCharacterLengths, runDescriptor.font, runDescriptor.attributes, JSRange(runDescriptor.location, runDescriptor.length));
+            run = JSTextRun.initWithGlyphs(runDescriptor.glyphs, runDescriptor.glyphCharacterLengths, runDescriptor.font, runDescriptor.attributes, JSRange(runDescriptor.location, runDescriptor.length), this.useDisplayMetrics);
             run.origin.x = x;
             x += run.size.width;
             runs.push(run);

package/Root/Frameworks/Foundation/JSURLRequest.js

@@ -46,6 +46,9 @@ JSClass("JSURLRequest", JSObject, {
     },
 
     redirectedRequestToURL: function(url){
+        if (!url.isAbsolute){
+            url.resolveToBaseURL(this.url);
+        }
         var request = JSURLRequest.initWithURL(url);
         request._method = this._method;
         request._headerMap = this._headerMap;

package/Root/Frameworks/Foundation/JSXMLParser.js

@@ -475,7 +475,7 @@ JSClass("JSXMLParser", JSObject, {
                 }
                 obj = readObject();
             }
-            if (!this.isStopped && this.delegate.xmlParserDidEndDocument){
+            if (!this.isStopped && this.delegate && this.delegate.xmlParserDidEndDocument){
                 this.delegate.xmlParserDidEndDocument(this);
             }
         }catch (e){

package/Root/Frameworks/Foundation/JSZip.js

@@ -11,9 +11,160 @@ JSClass("JSZip", JSObject, {
     init: function(){
         this.chunks = [];
         this.directory = [];
+        this.directoryIndexByFilename = {};
         this.offset = 0;
     },
 
+    initWithData: function(data){
+        if (data === null || data === undefined){
+            return null;
+        }
+        if (data.length < 22){
+            return null;
+        }
+        this._data = data;
+        this.directory = [];
+        this.directoryIndexByFilename = {};
+        var offset = this._data.length - 22;
+        var minOffset = Math.max(0, offset - 0xFFFF);
+        while (offset >= minOffset && !(this._data[offset] === 0x50 && this._data[offset+1] === 0x4b && this._data[offset+2] === 0x05 && this._data[offset+3] === 0x06)){
+            offset -= 1;
+        }
+        if (offset < minOffset){
+            return null;
+        }
+        var end = this._data.subdataInRange(JSRange(offset, this._data.length - offset));
+        var dataView = end.dataView();
+        // End of Central Directory Record (APPNOTE.txt 4.3.16)
+        // everything is little-endian
+        var signature = dataView.getUint32(0, true);
+        if (signature !== 0x06054b50){
+            return null;
+        }
+        var diskNumber = dataView.getUint16(4, true);
+        var diskNumberWithDirectoryStart = dataView.getUint16(6, true);
+        var numberOfItemsOnDisk = dataView.getUint16(8, true);
+        var numberOfItemsTotal = dataView.getUint16(10, true);
+        var sizeOfDirectory = dataView.getUint32(12, true);
+        var offsetOfDirectoryStart = dataView.getUint32(16, true);
+        var commentLength = dataView.getUint16(20, true);
+        if (diskNumber !== 0 || diskNumberWithDirectoryStart !== 0){
+            return null;
+        }
+        if (offsetOfDirectoryStart + sizeOfDirectory > this._data.length){
+            return null;
+        }
+        var directory = this._data.subdataInRange(JSRange(offsetOfDirectoryStart, sizeOfDirectory));
+        dataView = directory.dataView();
+        var crc;
+        var compressedLength;
+        var uncompressedLength;
+        var nameLength;
+        var extraFieldLength;
+        var name;
+        var headerOffset;
+        var offset = 0;
+        for (var i = 0; i < numberOfItemsTotal; ++i){
+            // Central Directory File Header (APPNOTE.txt 4.3.12)
+            // Everything is little-endian
+            if (offset + 46 > sizeOfDirectory){
+                return null;
+            }
+            signature = dataView.getUint32(offset + 0, true);
+            if (signature !== 0x02014b50){
+                return null;
+            }
+            crc = dataView.getUint32(offset + 16, true);
+            compressedLength = dataView.getUint32(offset + 20, true);
+            uncompressedLength = dataView.getUint32(offset + 24, true);
+            nameLength = dataView.getUint16(offset + 28, true);
+            extraFieldLength = dataView.getUint16(offset + 30, true);
+            commentLength = dataView.getUint16(offset + 32, true);
+            headerOffset = dataView.getUint32(offset + 42, true);
+            if (offset + 46 + nameLength > sizeOfDirectory){
+                return null;
+            }
+            name = directory.subdataInRange(JSRange(offset + 46, nameLength)).stringByDecodingUTF8();
+            this.directory.push({
+                name: name,
+                offset: headerOffset,
+                header: this.data.subdataInRange(JSRange(headerOffset, 30 + nameLength + extraFieldLength)),
+                crc: crc,
+                compressedLength: compressedLength,
+                uncompressedLength: uncompressedLength
+            });
+            this.directoryIndexByFilename[name] = i;
+            offset += 46 + nameLength + extraFieldLength + commentLength;
+        }
+
+    },
+
+    directoryIndexByFilename: null,
+    filenames: JSReadOnlyProperty(),
+
+    getFilenames: function(){
+        var filenames = [];
+        for (var i = 0, l = this.directory.length; i < l; ++i){
+            filenames.push(this.directory[i].name);
+        }
+        return filenames;
+    },
+
+    dataForFilename: function(filename){
+        var index = this.directoryIndexByFilename[filename];
+        if (index === undefined){
+            return null;
+        }
+        var file = this.directory[index];
+        var dataView = file.header.dataView();
+        var signature = dataView.getUint32(0, true);
+        if (signature !== 0x04034b50){
+            return null;
+        }
+        var version = dataView.getUint16(4, true);
+        var flags = dataView.getUint16(6, true);
+        var method = dataView.getUint16(8, true);
+        var crc = dataView.getUint32(14, true);
+        var compressedLength = dataView.getUint32(18, true);
+        var uncompressedLength = dataView.getUint32(22, true);
+        var nameLength = dataView.getUint16(26, true);
+        var extraFieldLength = dataView.getUint16(28, true);
+        var offset = file.offset + 30 + nameLength + extraFieldLength;
+        if (version > 20){
+            return null;
+        }
+        if (method !== 8){
+            return null;
+        }
+        if ((flags & 0x8) !== 0){
+            crc = file.crc;
+            compressedLength = file.compressedLength;
+            uncompressedLength = file.uncompressedLength;
+        }
+        if (offset + compressedLength > this.data.length){
+            return null;
+        }
+        if (compressedLength === 0 || uncompressedLength === 0){
+            return null;
+        }
+        var compressedData = this.data.subdataInRange(JSRange(offset, compressedLength));
+        var data = JSData.initWithLength(uncompressedLength);
+        var stream = DeflateStream();
+        stream.input = compressedData;
+        stream.output = data;
+        stream.inflate(true);
+        if (stream.state !== DeflateStream.State.done){
+            data = null;
+        }
+        if (data === null){
+            return;
+        }
+        if (JSCRC32(data) !== crc){
+            return null;
+        }
+        return data;
+    },
+
     offset: 0,
 
     addFile: function(file, completion, target){
@@ -83,7 +234,10 @@ JSClass("JSZip", JSObject, {
         this.directory.push({
             name: name,
             offset: this.offset,
-            header: header
+            header: header,
+            crc: crc,
+            compressedLength: storedData.length,
+            uncompressedLength: data.length
         });
         this.chunks.push(header);
         this.chunks.push(storedData);

package/Root/Frameworks/ImageKit/IKHTMLCanvasBitmapContext.js

@@ -167,9 +167,11 @@ JSClass("IKHTMLCanvasBitmapContext", IKBitmapContext, {
     drawPath: function(drawingMode){
         var path = this.path.copy();
         this.enqueueOperation(function(state, completion, target){
+            this.canvasContext.save();
             this.canvasContext.setTransform(1, 0, 0, 1, 0, 0);
             this.canvasContext.beginPath();
             path.addToIKHTMLCanvasContext(this.canvasContext);
+            this.canvasContext.restore();
             switch (drawingMode){
                 case JSContext.DrawingMode.fill:
                     this.canvasContext.fill();
@@ -213,19 +215,21 @@ JSClass("IKHTMLCanvasBitmapContext", IKBitmapContext, {
                     return;
                 }
                 var scale = Math.ceil(Math.max(state.transform.a, state.transform.b));
+                var size = JSSize(rect.size.width * scale, rect.size.height * scale);
                 var maskCanvas = this.canvasContext.canvas.ownerDocument.createElement("canvas");
-                maskCanvas.width = maskImage.size.width * scale;
-                maskCanvas.height = maskImage.size.height * scale;
+                maskCanvas.width = size.width;
+                maskCanvas.height = size.height;
                 var maskContext = maskCanvas.getContext('2d');
                 maskContext.fillStyle = state.fillColor.cssString();
-                maskContext.fillRect(0, 0, maskCanvas.width, maskCanvas.height);
+                maskContext.fillRect(0, 0, size.width, size.height);
                 maskContext.globalCompositeOperation = 'destination-in';
-                maskContext.drawImage(imgElement, 0, 0, maskCanvas.width, maskCanvas.height);
+                maskContext.drawImage(imgElement, 0, 0, size.width, size.height);
                 this.canvasContext.drawImage(maskCanvas, rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
                 completion.call(target);
             }, this);
         });
     },
+
     // ----------------------------------------------------------------------
     // MARK: - Images
 
@@ -249,17 +253,7 @@ JSClass("IKHTMLCanvasBitmapContext", IKBitmapContext, {
     drawLinearGradient: function(gradient, rect){
         this.enqueueOperation(function(state, completion, target){
             this.canvasContext.save();
-            var canvasGradient = this.canvasContext.createLinearGradient(
-                rect.origin.x + gradient.start.x * rect.size.width,
-                rect.origin.y + gradient.start.y * rect.size.height,
-                rect.origin.x + gradient.end.x * rect.size.width,
-                rect.origin.y + gradient.end.y * rect.size.height
-            );
-            var stop;
-            for (var i = 0, l = gradient.stops.length; i < l; ++i){
-                stop = gradient.stops[i];
-                canvasGradient.addColorStop(stop.position, stop.color.cssString());
-            }
+            var canvasGradient = this._linearGradientForCanvasContext(this.canvasContext, gradient, rect);
             this.canvasContext.fillStyle = canvasGradient;
             this.canvasContext.fillRect(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
             this.canvasContext.restore();
@@ -269,30 +263,8 @@ JSClass("IKHTMLCanvasBitmapContext", IKBitmapContext, {
 
     drawRadialGradient: function(gradient, rect){
         this.enqueueOperation(function(state, completion, target){
-            var r0 = 0;
-            var start = JSPoint(
-                rect.origin.x + gradient.start.x * rect.size.width,
-                rect.origin.y + gradient.start.y * rect.size.height
-            );
-            var end = JSPoint(
-                rect.origin.x + gradient.end.x * rect.size.width,
-                rect.origin.y + gradient.end.y * rect.size.height
-            );
-            var r1 = start.distanceToPoint(end);
+            var canvasGradient = this._radialGradientForCanvasContext(this.canvasContext, gradient, rect);
             this.canvasContext.save();
-            var canvasGradient = this.canvasContext.createRadialGradient(
-                start.x,
-                start.y,
-                r0,
-                start.x,
-                start.y,
-                r1
-            );
-            var stop;
-            for (var i = 0, l = gradient.stops.length; i < l; ++i){
-                stop = gradient.stops[i];
-                canvasGradient.addColorStop(stop.position, stop.color.cssString());
-            }
             this.canvasContext.fillStyle = canvasGradient;
             this.canvasContext.fillRect(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
             this.canvasContext.restore();
@@ -300,22 +272,61 @@ JSClass("IKHTMLCanvasBitmapContext", IKBitmapContext, {
         });
     },
 
-    drawLinearGradientStroke: function(gradient, path){
+    drawMaskedLinearGradient: function(gradient, rect, maskImage){
+        this.enqueueOperation(function(state, completion, target){
+            drawableElementForImage(maskImage, this.canvasContext.canvas.ownerDocument, function(imgElement){
+                if (imgElement === null){
+                    completion.call(target);
+                    return;
+                }
+                var scale = Math.ceil(Math.max(state.transform.a, state.transform.b));
+                var size = JSSize(rect.size.width * scale, rect.size.height * scale);
+                var maskCanvas = this.canvasContext.canvas.ownerDocument.createElement("canvas");
+                maskCanvas.width = size.width;
+                maskCanvas.height = size.height;
+                var maskContext = maskCanvas.getContext('2d');
+                var canvasGradient = this._linearGradientForCanvasContext(maskContext, gradient, JSRect(JSPoint.Zero, size));
+                maskContext.fillStyle = canvasGradient;
+                maskContext.fillRect(0, 0, size.width, size.height);
+                maskContext.globalCompositeOperation = 'destination-in';
+                maskContext.drawImage(imgElement, 0, 0, size.width, size.height);
+                this.canvasContext.drawImage(maskCanvas, rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
+                completion.call(target);
+            }, this);
+        });
+    },
+
+    drawMaskedRadialGradient: function(gradient, rect, maskImage){
+        this.enqueueOperation(function(state, completion, target){
+            drawableElementForImage(maskImage, this.canvasContext.canvas.ownerDocument, function(imgElement){
+                if (imgElement === null){
+                    completion.call(target);
+                    return;
+                }
+                var scale = Math.ceil(Math.max(state.transform.a, state.transform.b));
+                var size = JSSize(rect.size.width * scale, rect.size.height * scale);
+                var maskCanvas = this.canvasContext.canvas.ownerDocument.createElement("canvas");
+                maskCanvas.width = size.width;
+                maskCanvas.height = size.height;
+                var maskContext = maskCanvas.getContext('2d');
+                var canvasGradient = this._radialGradientForCanvasContext(maskContext, gradient, JSRect(JSPoint.Zero, size));
+                maskContext.fillStyle = canvasGradient;
+                maskContext.fillRect(0, 0, size.width, size.height);
+                maskContext.globalCompositeOperation = 'destination-in';
+                maskContext.drawImage(imgElement, 0, 0, size.width, size.height);
+                this.canvasContext.drawImage(maskCanvas, rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
+                completion.call(target);
+            }, this);
+        });
+    },
+
+    drawLinearGradientStroke: function(gradient, path, alternateRect){
         this.enqueueOperation(function(state, completion, target){
             var rect = path.boundingRect;
             this.canvasContext.save();
-            this.addPath(path);
-            var canvasGradient = this.canvasContext.createLinearGradient(
-                rect.origin.x + gradient.start.x * rect.size.width,
-                rect.origin.y + gradient.start.y * rect.size.height,
-                rect.origin.x + gradient.end.x * rect.size.width,
-                rect.origin.y + gradient.end.y * rect.size.height
-            );
-            var stop;
-            for (var i = 0, l = gradient.stops.length; i < l; ++i){
-                stop = gradient.stops[i];
-                canvasGradient.addColorStop(stop.position, stop.color.cssString());
-            }
+            this.canvasContext.beginPath();
+            path.addToIKHTMLCanvasContext(this.canvasContext);
+            var canvasGradient = this._linearGradientForCanvasContext(this.canvasContext, gradient, alternateRect || rect);
             this.canvasContext.strokeStyle = canvasGradient;
             this.canvasContext.stroke();
             this.canvasContext.restore();
@@ -324,34 +335,13 @@ JSClass("IKHTMLCanvasBitmapContext", IKBitmapContext, {
         this.beginPath();
     },
 
-    drawRadialGradientStroke: function(gradient, path){
+    drawRadialGradientStroke: function(gradient, path, alternateRect){
         this.enqueueOperation(function(state, completion, target){
             var rect = path.boundingRect;
-            var r0 = 0;
-            var start = JSPoint(
-                rect.origin.x + gradient.start.x * rect.size.width,
-                rect.origin.y + gradient.start.y * rect.size.height
-            );
-            var end = JSPoint(
-                rect.origin.x + gradient.end.x * rect.size.width,
-                rect.origin.y + gradient.end.y * rect.size.height
-            );
-            var r1 = start.distanceToPoint(end);
             this.canvasContext.save();
-            this.addPath(path);
-            var canvasGradient = this.canvasContext.createRadialGradient(
-                start.x,
-                start.y,
-                r0,
-                start.x,
-                start.y,
-                r1
-            );
-            var stop;
-            for (var i = 0, l = gradient.stops.length; i < l; ++i){
-                stop = gradient.stops[i];
-                canvasGradient.addColorStop(stop.position, stop.color.cssString());
-            }
+            this.canvasContext.beginPath();
+            path.addToIKHTMLCanvasContext(this.canvasContext);
+            var canvasGradient = this._radialGradientForCanvasContext(this.canvasContext, gradient, alternateRect || rect);
             this.canvasContext.strokeStyle = canvasGradient;
             this.canvasContext.stroke();
             this.canvasContext.restore();
@@ -360,6 +350,105 @@ JSClass("IKHTMLCanvasBitmapContext", IKBitmapContext, {
         this.beginPath();
     },
 
+    _linearGradientForCanvasContext: function(canvasContext, gradient, rect){
+        var canvasGradient = canvasContext.createLinearGradient(
+            rect.origin.x + gradient.start.x * rect.size.width,
+            rect.origin.y + gradient.start.y * rect.size.height,
+            rect.origin.x + gradient.end.x * rect.size.width,
+            rect.origin.y + gradient.end.y * rect.size.height
+        );
+        var stop;
+        for (var i = 0, l = gradient.stops.length; i < l; ++i){
+            stop = gradient.stops[i];
+            canvasGradient.addColorStop(stop.position, stop.color.cssString());
+        }
+        return canvasGradient;
+    },
+
+    _radialGradientForCanvasContext: function(canvasContext, gradient, rect){
+        var r0 = 0;
+        var start = JSPoint(
+            rect.origin.x + gradient.start.x * rect.size.width,
+            rect.origin.y + gradient.start.y * rect.size.height
+        );
+        var end = JSPoint(
+            rect.origin.x + gradient.end.x * rect.size.width,
+            rect.origin.y + gradient.end.y * rect.size.height
+        );
+        var r1 = start.distanceToPoint(end);
+        var canvasGradient = canvasContext.createRadialGradient(
+            start.x,
+            start.y,
+            r0,
+            start.x,
+            start.y,
+            r1
+        );
+        var stop;
+        for (var i = 0, l = gradient.stops.length; i < l; ++i){
+            stop = gradient.stops[i];
+            canvasGradient.addColorStop(stop.position, stop.color.cssString());
+        }
+        return canvasGradient;
+    },
+
+    // ----------------------------------------------------------------------
+    // MARK: - Transparency Layers 
+
+    _reusableTransparencyLayer: null,
+
+    createTransparencyLayer: function(){
+        if (this._reusableTransparencyLayer !== null){
+            layer = this._reusableTransparencyLayer;
+            this._reusableTransparencyLayer = null;
+            layer.context.resetTransform();
+            layer.context.clearRect(0, 0, layer.canvas.width, layer.canvas.height);
+            this._canvasContextAdoptState(layer.context, this.state);
+            layer.parentContext = this.canvasContext;
+            this.canvasContext = layer.context;
+            return layer;
+        }
+        var parentContext = this.canvasContext;
+        var canvas = this.canvasElement.ownerDocument.createElement("canvas");
+        canvas.width = this.canvasElement.width;
+        canvas.height = this.canvasElement.height;
+        var context = canvas.getContext("2d");
+        this._canvasContextAdoptState(context, this.state);
+        var layer = {
+            canvas: canvas,
+            context: context,
+            parentContext: parentContext
+        };
+        this.canvasContext = context;
+        return layer;
+    },
+
+    drawTransparencyLayer: function(transparencyLayer){
+        this.canvasContext = transparencyLayer.parentContext;
+        this.canvasContext.resetTransform();
+        this.canvasContext.drawImage(transparencyLayer.canvas, 0, 0);
+        this._reusableTransparencyLayer = transparencyLayer;
+    },
+
+    _canvasContextAdoptState: function(context, state){
+        context.globalAlpha = state.alpha;
+        context.fillStyle = state.fillColor ? state.fillColor.cssString() : '';
+        context.strokeStyle = state.strokeColor ? state.strokeColor.cssString() : '';
+        context.shadowOffsetX = state.shadowOffset.x;
+        context.shadowOffsetY = state.shadowOffset.y;
+        context.shadowBlur = state.shadowBlur;
+        context.shadowColor = state.shadowColor ? state.shadowColor.cssString() : '';
+        context.lineWidth = state.lineWidth;
+        context.lineCap = state.lineCap;
+        context.lineJoin = state.lineJoin;
+        context.miterLimit = state.miterLimit;
+        context.lineDashOffset = state.lineDashPhase;
+        context.setLineDash(state.lineDashArray);
+        var transform = state.transform;
+        context.setTransform(transform.a, transform.b, transform.c, transform.d, transform.tx, transform.ty);
+        context.font = state.font ? state.font.cssString() : '';
+    },
+
     // ----------------------------------------------------------------------
     // MARK: - Text
 
@@ -502,31 +591,24 @@ JSPath.definePropertiesFromExtensions({
 
     addToIKHTMLCanvasContext: function(canvasContext){
         var i, l;
-        var j, k;
-        var subpath;
-        var segment;
-        var point;
-        var cp1;
-        var cp2;
-        for (i = 0, l = this.subpaths.length; i < l; ++i){
-            subpath = this.subpaths[i];
-            canvasContext.moveTo(subpath.firstPoint.x, subpath.firstPoint.y);
-            for (j = 0, k = subpath.segments.length; j < k; ++j){
-                segment = subpath.segments[j];
-                if (segment.type === JSPath.SegmentType.line){
-                    canvasContext.lineTo(segment.end.x, segment.end.y);
-                }else if (segment.type === JSPath.SegmentType.curve){
-                    canvasContext.bezierCurveTo(
-                        segment.curve.cp1.x,
-                        segment.curve.cp1.y,
-                        segment.curve.cp2.x,
-                        segment.curve.cp2.y,
-                        segment.curve.p2.x,
-                        segment.curve.p2.y
-                    );
-                }
-            }
-            if (subpath.closed){
+        var elements = this.elements;
+        var element;
+        for (i = 0, l = elements.length; i < l; ++i){
+            element = elements[i];
+            if (element.type === JSPathElement.Type.move){
+                canvasContext.moveTo(element.point.x, element.point.y);
+            }else if (element.type === JSPathElement.Type.line){
+                canvasContext.lineTo(element.point.x, element.point.y);
+            }else if (element.type === JSPathElement.Type.cubicCurve){
+                canvasContext.bezierCurveTo(
+                    element.curve.cp1.x,
+                    element.curve.cp1.y,
+                    element.curve.cp2.x,
+                    element.curve.cp2.y,
+                    element.curve.p2.x,
+                    element.curve.p2.y
+                );
+            }else if (element.type === JSPathElement.Type.close){
                 canvasContext.closePath();
             }
         }
@@ -535,6 +617,10 @@ JSPath.definePropertiesFromExtensions({
 });
 
 var drawableElementForImage = function(image, domDocument, completion, target){
+    if (image._htmlImage !== undefined && image._htmlImage !== null){
+        completion.call(target, image._htmlImage);
+        return;
+    }
     var imgElement = domDocument.createElement("img");
     imgElement.setAttribute("crossorigin", "anonymous");
     imgElement.src = image.htmlURLString();

package/Root/Frameworks/ImageKit/IKNodeBitmapContext.js

@@ -185,10 +185,10 @@ JSClass("IKNodeBitmapContext", IKBitmapContext, {
         squarePath.addLineToPoint(JSPoint(1, 1));
         squarePath.addLineToPoint(JSPoint(0, 1));
         squarePath.close();
-        var p1 = squarePath.subpaths[0].firstPoint;
-        var p2 = squarePath.subpaths[0].segments[0].end;
-        var p3 = squarePath.subpaths[0].segments[1].end;
-        var p4 = squarePath.subpaths[0].segments[2].end;
+        var p1 = squarePath.elements[0].point;
+        var p2 = squarePath.elements[1].point;
+        var p3 = squarePath.elements[2].point;
+        var p4 = squarePath.elements[3].point;
         for (var i = 0; p1.y < bitmap.size.height; ++p1.y, ++p2.y, ++p3.y, ++p4.y){
             for (p1.x = 0, p2.x = 1, p3.x = 1, p4.x = 0; p1.x < bitmap.size.width; ++p1.x, ++p2.x, ++p3.x, ++p4.x){
                 r = bitmap.data[i++];

package/Root/Frameworks/ImageKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.ImageKit
-JSBundleVersion: 2026.10.0
+JSBundleVersion: 2026.26.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments:

package/Root/Frameworks/MediaKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.MediaKit
-JSBundleVersion: 2026.10.0
+JSBundleVersion: 2026.26.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments:

package/Root/Frameworks/MediaKitUI/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.MediaKitUI
-JSBundleVersion: 2026.10.0
+JSBundleVersion: 2026.26.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments:

package/Root/Frameworks/NotificationKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.NotificationKit
-JSBundleVersion: 2026.10.0
+JSBundleVersion: 2026.26.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2021 Breakside Inc.
 JSBundleEnvironments:

package/Root/Frameworks/PDFKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.PDFKit
-JSBundleVersion: 2026.10.0
+JSBundleVersion: 2026.26.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSLicenseNotice: |

package/Root/Frameworks/QRKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.QRKit
-JSBundleVersion: 2026.10.0
+JSBundleVersion: 2026.26.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSLicenseNotice: |

package/Root/Frameworks/SearchKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.SearchKit
-JSBundleVersion: 2026.10.0
+JSBundleVersion: 2026.26.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSLicenseNotice: |

package/Root/Frameworks/SecurityKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.SecurityKit
-JSBundleVersion: 2026.10.0
+JSBundleVersion: 2026.26.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments: