expo-camera 56.0.4 → 56.0.6

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXBinarizer.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <CoreGraphics/CoreGraphics.h>
+#import "ZXBitArray.h"
+#import "ZXBitMatrix.h"
+#import "ZXLuminanceSource.h"
+
+/**
+ * This class hierarchy provides a set of methods to convert luminance data to 1 bit data.
+ * It allows the algorithm to vary polymorphically, for example allowing a very expensive
+ * thresholding technique for servers and a fast one for mobile. It also permits the implementation
+ * to vary, e.g. a JNI version for Android and a Java fallback version for other platforms.
+ */
+@interface ZXBinarizer : NSObject
+
+@property (nonatomic, strong, readonly) ZXLuminanceSource *luminanceSource;
+@property (nonatomic, assign, readonly) int width;
+@property (nonatomic, assign, readonly) int height;
+
+- (id)initWithSource:(ZXLuminanceSource *)source;
++ (id)binarizerWithSource:(ZXLuminanceSource *)source;
+
+/**
+ * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+ * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+ * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+ * For callers which only examine one row of pixels at a time, the same BitArray should be reused
+ * and passed in with each call for performance. However it is legal to keep more than one row
+ * at a time if needed.
+ *
+ * @param y The row to fetch, which must be in [0, bitmap height)
+ * @param row An optional preallocated array. If null or too small, it will be ignored.
+ *            If used, the Binarizer will call ZXBitArray clear. Always use the returned object.
+ * @return The array of bits for this row (true means black) or nil if row can't be binarized.
+ */
+- (ZXBitArray *)blackRow:(int)y row:(ZXBitArray *)row error:(NSError **)error;
+
+/**
+ * Converts a 2D array of luminance data to 1 bit data. As above, assume this method is expensive
+ * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+ * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+ * fetched using getBlackRow(), so don't mix and match between them.
+ *
+ * @return The 2D array of bits for the image (true means black) or nil if image can't be binarized
+ * to make a matrix.
+ */
+- (ZXBitMatrix *)blackMatrixWithError:(NSError **)error;
+
+/**
+ * Creates a new object with the same type as this Binarizer implementation, but with pristine
+ * state. This is needed because Binarizer implementations may be stateful, e.g. keeping a cache
+ * of 1 bit data. See Effective Java for why we can't use Java's clone() method.
+ *
+ * @param source The LuminanceSource this Binarizer will operate on.
+ * @return A new concrete Binarizer implementation object.
+ */
+- (ZXBinarizer *)createBinarizer:(ZXLuminanceSource *)source;
+
+- (CGImageRef)createImage CF_RETURNS_RETAINED;
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXBinaryBitmap.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class ZXBinarizer, ZXBitArray, ZXBitMatrix;
+
+/**
+ * This class is the core bitmap class used by ZXing to represent 1 bit data. Reader objects
+ * accept a BinaryBitmap and attempt to decode it.
+ */
+@interface ZXBinaryBitmap : NSObject
+
+/**
+ * @return The width of the bitmap.
+ */
+@property (nonatomic, readonly) int width;
+
+/**
+ * @return The height of the bitmap.
+ */
+@property (nonatomic, readonly) int height;
+
+/**
+ * @return Whether this bitmap can be cropped.
+ */
+@property (nonatomic, readonly) BOOL cropSupported;
+
+/**
+ * @return Whether this bitmap supports counter-clockwise rotation.
+ */
+@property (nonatomic, readonly) BOOL rotateSupported;
+
+- (id)initWithBinarizer:(ZXBinarizer *)binarizer;
+
++ (id)binaryBitmapWithBinarizer:(ZXBinarizer *)binarizer;
+
+/**
+ * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+ * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+ * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+ *
+ * @param y The row to fetch, which must be in [0, bitmap height)
+ * @param row An optional preallocated array. If null or too small, it will be ignored.
+ *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
+ * @return The array of bits for this row (true means black) or nil if row can't be binarized.
+ */
+- (ZXBitArray *)blackRow:(int)y row:(ZXBitArray *)row error:(NSError **)error;
+
+/**
+ * Converts a 2D array of luminance data to 1 bit. As above, assume this method is expensive
+ * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+ * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+ * fetched using getBlackRow(), so don't mix and match between them.
+ *
+ * @return The 2D array of bits for the image (true means black) or nil if image can't be binarized
+ *   to make a matrix.
+ */
+- (ZXBitMatrix *)blackMatrixWithError:(NSError **)error;
+
+/**
+ * Returns a new object with cropped image data. Implementations may keep a reference to the
+ * original data rather than a copy. Only callable if isCropSupported() is true.
+ *
+ * @param left The left coordinate, which must be in [0,getWidth())
+ * @param top The top coordinate, which must be in [0,getHeight())
+ * @param width The width of the rectangle to crop.
+ * @param height The height of the rectangle to crop.
+ * @return A cropped version of this object.
+ */
+- (ZXBinaryBitmap *)crop:(int)left top:(int)top width:(int)width height:(int)height;
+
+/**
+ * Returns a new object with rotated image data by 90 degrees counterclockwise.
+ * Only callable if `rotateSupported` is true.
+ *
+ * @return A rotated version of this object.
+ */
+- (ZXBinaryBitmap *)rotateCounterClockwise;
+
+/**
+ * Returns a new object with rotated image data by 45 degrees counterclockwise.
+ * Only callable if `rotateSupported` is true.
+ *
+ * @return A rotated version of this object.
+ */
+- (ZXBinaryBitmap *)rotateCounterClockwise45;
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXBitArray.h

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class ZXByteArray, ZXIntArray;
+
+/**
+ * A simple, fast array of bits, represented compactly by an array of ints internally.
+ */
+@interface ZXBitArray : NSObject <NSCopying>
+
+/**
+ * @return underlying array of ints. The first element holds the first 32 bits, and the least
+ *         significant bit is bit 0.
+ */
+@property (nonatomic, assign, readonly) int32_t *bits;
+
+@property (nonatomic, assign, readonly) int size;
+
+- (id)initWithSize:(int)size;
+
+- (int)sizeInBytes;
+
+/**
+ * @param i bit to get
+ * @return true iff bit i is set
+ */
+- (BOOL)get:(int)i;
+
+/**
+ * Sets bit i.
+ *
+ * @param i bit to set
+ */
+- (void)set:(int)i;
+
+/**
+ * Flips bit i.
+ *
+ * @param i bit to set
+ */
+- (void)flip:(int)i;
+
+/**
+ * @param from first bit to check
+ * @return index of first bit that is set, starting from the given index, or size if none are set
+ *  at or beyond this given index
+ */
+- (int)nextSet:(int)from;
+
+/**
+ * @param from index to start looking for unset bit
+ * @return index of next unset bit, or size if none are unset until the end
+ * @see nextSet:
+ */
+- (int)nextUnset:(int)from;
+
+/**
+ * Sets a block of 32 bits, starting at bit i.
+ *
+ * @param i first bit to set
+ * @param newBits the new value of the next 32 bits. Note again that the least-significant bit
+ * corresponds to bit i, the next-least-significant to i+1, and so on.
+ */
+- (void)setBulk:(int)i newBits:(int32_t)newBits;
+
+/**
+ * Sets a range of bits.
+ *
+ * @param start start of range, inclusive.
+ * @param end end of range, exclusive
+ */
+- (void)setRange:(int)start end:(int)end;
+
+/**
+ * Clears all bits (sets to false).
+ */
+- (void)clear;
+
+/**
+ * Efficient method to check if a range of bits is set, or not set.
+ *
+ * @param start start of range, inclusive.
+ * @param end end of range, exclusive
+ * @param value if true, checks that bits in range are set, otherwise checks that they are not set
+ * @return true iff all bits are set or not set in range, according to value argument
+ * @throws NSInvalidArgumentException if end is less than or equal to start
+ */
+- (BOOL)isRange:(int)start end:(int)end value:(BOOL)value;
+
+- (void)appendBit:(BOOL)bit;
+
+/**
+ * Appends the least-significant bits, from value, in order from most-significant to
+ * least-significant. For example, appending 6 bits from 0x000001E will append the bits
+ * 0, 1, 1, 1, 1, 0 in that order.
+ *
+ * @param value in32_t containing bits to append
+ * @param numBits bits from value to append
+ */
+- (void)appendBits:(int32_t)value numBits:(int)numBits;
+
+- (void)appendBitArray:(ZXBitArray *)other;
+
+- (void)xor:(ZXBitArray *)other;
+
+/**
+ *
+ * @param bitOffset first bit to start writing
+ * @param array array to write into. Bytes are written most-significant byte first. This is the opposite
+ *  of the internal representation, which is exposed by `bitArray`
+ * @param offset position in array to start writing
+ * @param numBytes how many bytes to write
+ */
+- (void)toBytes:(int)bitOffset array:(ZXByteArray *)array offset:(int)offset numBytes:(int)numBytes;
+
+/**
+ * @return underlying array of ints. The first element holds the first 32 bits, and the least
+ *         significant bit is bit 0.
+ */
+- (ZXIntArray *)bitArray;
+
+/**
+ * Reverses all bits in the array.
+ */
+- (void)reverse;
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXBitMatrix.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class ZXBitArray, ZXIntArray;
+
+/**
+ * Represents a 2D matrix of bits. In function arguments below, and throughout the common
+ * module, x is the column position, and y is the row position. The ordering is always x, y.
+ * The origin is at the top-left.
+ *
+ * Internally the bits are represented in a 1-D array of 32-bit ints. However, each row begins
+ * with a new NSInteger. This is done intentionally so that we can copy out a row into a BitArray very
+ * efficiently.
+ *
+ * The ordering of bits is row-major. Within each NSInteger, the least significant bits are used first,
+ * meaning they represent lower x values. This is compatible with BitArray's implementation.
+ */
+@interface ZXBitMatrix : NSObject <NSCopying>
+
+/**
+ * @return The width of the matrix
+ */
+@property (nonatomic, assign, readonly) int width;
+
+/**
+ * @return The height of the matrix
+ */
+@property (nonatomic, assign, readonly) int height;
+
+@property (nonatomic, assign, readonly) int32_t *bits;
+
+/**
+ * @return The row size of the matrix
+ */
+@property (nonatomic, assign, readonly) int rowSize;
+
+// A helper to construct a square matrix.
+- (id)initWithDimension:(int)dimension;
+- (id)initWithWidth:(int)width height:(int)height;
+
++ (ZXBitMatrix *)parse:(NSString *)stringRepresentation
+             setString:(NSString *)setString
+           unsetString:(NSString *)unsetString;
+
+/**
+ * Gets the requested bit, where true means black.
+ *
+ * @param x The horizontal component (i.e. which column)
+ * @param y The vertical component (i.e. which row)
+ * @return value of given bit in matrix
+ */
+- (BOOL)getX:(int)x y:(int)y;
+
+/**
+ * Sets the given bit to true.
+ *
+ * @param x The horizontal component (i.e. which column)
+ * @param y The vertical component (i.e. which row)
+ */
+- (void)setX:(int)x y:(int)y;
+
+- (void)unsetX:(int)x y:(int)y;
+
+/**
+ * Flips the given bit.
+ *
+ * @param x The horizontal component (i.e. which column)
+ * @param y The vertical component (i.e. which row)
+ */
+- (void)flipX:(int)x y:(int)y;
+
+/**
+ * Exclusive-or (XOR): Flip the bit in this ZXBitMatrix if the corresponding
+ * mask bit is set.
+ *
+ * @param mask XOR mask
+ */
+- (void)xor:(ZXBitMatrix *)mask;
+
+/**
+ * Clears all bits (sets to false).
+ */
+- (void)clear;
+
+/**
+ * Sets a square region of the bit matrix to true.
+ *
+ * @param left The horizontal position to begin at (inclusive)
+ * @param top The vertical position to begin at (inclusive)
+ * @param width The width of the region
+ * @param height The height of the region
+ */
+- (void)setRegionAtLeft:(int)left top:(int)top width:(int)width height:(int)height;
+
+/**
+ * A fast method to retrieve one row of data from the matrix as a ZXBitArray.
+ *
+ * @param y The row to retrieve
+ * @param row An optional caller-allocated BitArray, will be allocated if null or too small
+ * @return The resulting BitArray - this reference should always be used even when passing
+ *         your own row
+ */
+- (ZXBitArray *)rowAtY:(int)y row:(ZXBitArray *)row;
+
+/**
+ * @param y row to set
+ * @param row ZXBitArray to copy from
+ */
+- (void)setRowAtY:(int)y row:(ZXBitArray *)row;
+
+/**
+ * Modifies this ZXBitMatrix to represent the same but rotated 180 degrees
+ */
+- (void)rotate180;
+
+/**
+ * This is useful in detecting the enclosing rectangle of a 'pure' barcode.
+ *
+ * @return {left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white
+ */
+- (ZXIntArray *)enclosingRectangle;
+
+/**
+ * This is useful in detecting a corner of a 'pure' barcode.
+ *
+ * @return {x,y} coordinate of top-left-most 1 bit, or null if it is all white
+ */
+- (ZXIntArray *)topLeftOnBit;
+
+- (ZXIntArray *)bottomRightOnBit;
+
+- (NSString *)descriptionWithSetString:(NSString *)setString unsetString:(NSString *)unsetString;
+
+/**
+ * @deprecated call descriptionWithSetString:unsetString: only, which uses \n line separator always
+ */
+- (NSString *)descriptionWithSetString:(NSString *)setString unsetString:(NSString *)unsetString
+                         lineSeparator:(NSString *)lineSeparator DEPRECATED_ATTRIBUTE;
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXBitSource.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@class ZXByteArray;
+
+/**
+ * This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
+ * number of bits read is not often a multiple of 8.
+ *
+ * This class is thread-safe but not reentrant -- unless the caller modifies the bytes array
+ * it passed in, in which case all bets are off.
+ */
+@interface ZXBitSource : NSObject
+
+/**
+ * @return index of next bit in current byte which would be read by the next call to `readBits:`.
+ */
+@property (nonatomic, assign, readonly) int bitOffset;
+
+/**
+ * @return index of next byte in input byte array which would be read by the next call to `readBits:`.
+ */
+@property (nonatomic, assign, readonly) int byteOffset;
+
+/**
+ * @param bytes bytes from which this will read bits. Bits will be read from the first byte first.
+ * Bits are read within a byte from most-significant to least-significant bit.
+ */
+- (id)initWithBytes:(ZXByteArray *)bytes;
+
+/**
+ * @param numBits number of bits to read
+ * @return int representing the bits read. The bits will appear as the least-significant
+ *         bits of the int
+ * @throws NSInvalidArgumentException if numBits isn't in [1,32] or more than is available
+ */
+- (int)readBits:(int)numBits;
+
+/**
+ * @return number of bits that can be read successfully
+ */
+- (int)available;
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXBizcardResultParser.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractDoCoMoResultParser.h"
+
+/**
+ * Implements the "BIZCARD" address book entry format, though this has been
+ * largely reverse-engineered from examples observed in the wild -- still
+ * looking for a definitive reference.
+ */
+@interface ZXBizcardResultParser : ZXAbstractDoCoMoResultParser
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXBookmarkDoCoMoResultParser.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXAbstractDoCoMoResultParser.h"
+
+@interface ZXBookmarkDoCoMoResultParser : ZXAbstractDoCoMoResultParser
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXBoolArray.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2014 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@interface ZXBoolArray : NSObject
+
+@property (nonatomic, assign, readonly) BOOL *array;
+@property (nonatomic, assign, readonly) unsigned int length;
+
+- (id)initWithLength:(unsigned int)length;
+- (id)initWithLength:(unsigned int)length values:(int)value1, ...;
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXByQuadrantReader.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "ZXReader.h"
+
+/**
+ * This class attempts to decode a barcode from an image, not by scanning the whole image,
+ * but by scanning subsets of the image. This is important when there may be multiple barcodes in
+ * an image, and detecting a barcode may find parts of multiple barcode and fail to decode
+ * (e.g. QR Codes). Instead this scans the four quadrants of the image -- and also the center
+ * 'quadrant' to cover the case where a barcode is found in the center.
+ */
+@interface ZXByQuadrantReader : NSObject <ZXReader>
+
+- (id)initWithDelegate:(id<ZXReader>)delegate;
+
+@end

package/prebuilds/spm-deps/ZXingObjC/release/ZXingObjC.xcframework/ios-arm64_x86_64-simulator/ZXingObjC.framework/Headers/ZXingObjC/ZXByteArray.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2014 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+@interface ZXByteArray : NSObject
+
+@property (nonatomic, assign, readonly) int8_t *array;
+@property (nonatomic, assign, readonly) unsigned int length;
+
+- (id)initWithLength:(unsigned int)length;
+- (id)initWithArray:(int8_t *)array length:(unsigned int)length;
+- (id)initWithBytes:(int)byte1, ...;
+- (id)initWithLength:(unsigned int)length bytes:(int)byte1, ...;
+
+@end