slidge-whatsapp 0.2.2__cp312-cp312-manylinux_2_36_aarch64.whl → 0.2.6__cp312-cp312-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/include/mupdf/fitz/getopt.h

@@ -0,0 +1,128 @@
+// Copyright (C) 2004-2021 Artifex Software, Inc.
+//
+// This file is part of MuPDF.
+//
+// MuPDF is free software: you can redistribute it and/or modify it under the
+// terms of the GNU Affero General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+// details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
+//
+// Alternative licensing terms are available from the licensor.
+// For commercial licensing, see <https://www.artifex.com/> or contact
+// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
+// CA 94129, USA, for further information.
+
+#ifndef MUPDF_FITZ_GETOPT_H
+#define MUPDF_FITZ_GETOPT_H
+
+#include "export.h"
+
+typedef struct
+{
+	char *option;
+	int *flag;
+	void *opaque;
+} fz_getopt_long_options;
+
+/**
+	Simple functions/variables for use in tools.
+
+	ostr = option string. Comprises single letter options, followed by : if there
+	is an argument to the option.
+
+	longopts: NULL (indicating no long options), or a pointer to an array of
+	longoptions, terminated by an entry with option == NULL.
+
+	In the event of matching a single char option, this function will normally
+	return the char. The exception to this is when the option requires an
+	argument and none is supplied; in this case we return ':'.
+
+	In the event of matching a long option, this function returns 0, with fz_optlong
+	set to point to the matching option.
+
+	A long option entry may be followed with : to indicate there is an argument to the
+	option. If the need for an argument is specified in this way, and no argument is
+	given, an error will be displayed and argument processing will stop. If an argument
+	is given, and the long option record contains a non-null flag pointer, then the code
+	will decode the argument and fill in that flag pointer. Specifically,
+	case-insensitive matches to 'yes', 'no', 'true' and 'false' will cause a value of 0
+	or 1 as appropriate to be written; failing this the arg will be interpreted as a
+	decimal integer using atoi.
+
+	A long option entry may be followed by an list of options (e.g. myoption=foo|bar|baz)
+	and the option will be passed to fz_opt_from_list. The return value of that will be
+	placed in fz_optitem. If the return value of that function is -1, then an error will
+	be displayed and argument processing will stop.
+
+	In the event of reaching the end of the arg list or '--', this function returns EOF.
+
+	In the event of failing to match anything, an error is printed, and we return '?'.
+
+	If an argument is expected for the option, then fz_optarg will be returned pointing
+	at the start of the argument. Examples of supported argument formats: '-r500', '-r 500',
+	'--resolution 500', '--resolution=500'.
+*/
+extern int fz_getopt_long(int nargc, char * const *nargv, const char *ostr, const fz_getopt_long_options *longopts);
+
+/**
+	Identical to fz_getopt_long, but with a NULL longopts field, signifying no long
+	options.
+*/
+extern int fz_getopt(int nargc, char * const *nargv, const char *ostr);
+
+/**
+	fz_optind is updated to point to the current index being read from the
+	arguments.
+*/
+FZ_DATA extern int fz_optind;
+
+/**
+	fz_optarg is a pointer to the argument data for the most recently
+	read option.
+*/
+FZ_DATA extern char *fz_optarg;
+
+/**
+	fz_optlong is a pointer to the record for the most recently
+	read long option. (i.e. if a long option is detected, this
+	will be set to point to the record for that option, otherwise
+	it will be NULL).
+*/
+FZ_DATA extern const fz_getopt_long_options *fz_optlong;
+
+/**
+	The item number for the most recently matched item list.
+
+	First item in the list is numbered 0. No match is -1.
+*/
+FZ_DATA extern int fz_optitem;
+
+/**
+	Return the index of a (case-insensitive) option within an optlist.
+
+	For instance for optlist = "Foo|Bar|Baz", and  opt = "bar",
+	this would return 1.
+
+	If the optlist ends with "|*" then that is a catch all case and
+	matches all options allowing the caller to process it itself.
+	fz_optarg will be set to point to the option, and the return
+	value will be the index of the '*' option within that list.
+
+	If an optlist entry ends with ':' (e.g. "Foo:") then that option
+	may have suboptions appended to it (for example "JPG:80") and
+	fz_optarg will be set to point at "80". Otherwise fz_optarg will
+	be set to NULL.
+
+	In the event of no-match found, prints an error and returns -1.
+*/
+int fz_opt_from_list(char *opt, const char *optlist);
+
+#endif

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/include/mupdf/fitz/glyph-cache.h

@@ -0,0 +1,96 @@
+// Copyright (C) 2004-2021 Artifex Software, Inc.
+//
+// This file is part of MuPDF.
+//
+// MuPDF is free software: you can redistribute it and/or modify it under the
+// terms of the GNU Affero General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+// details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
+//
+// Alternative licensing terms are available from the licensor.
+// For commercial licensing, see <https://www.artifex.com/> or contact
+// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
+// CA 94129, USA, for further information.
+
+#ifndef MUPDF_FITZ_GLYPH_CACHE_H
+#define MUPDF_FITZ_GLYPH_CACHE_H
+
+#include "mupdf/fitz/context.h"
+#include "mupdf/fitz/geometry.h"
+#include "mupdf/fitz/font.h"
+#include "mupdf/fitz/pixmap.h"
+#include "mupdf/fitz/device.h"
+
+/**
+	Purge all the glyphs from the cache.
+*/
+void fz_purge_glyph_cache(fz_context *ctx);
+
+/**
+	Create a pixmap containing a rendered glyph.
+
+	Lookup gid from font, clip it with scissor, and rendering it
+	with aa bits of antialiasing into a new pixmap.
+
+	The caller takes ownership of the pixmap and so must free it.
+
+	Note: This function is no longer used for normal rendering
+	operations, and is kept around just because we use it in the
+	app. It should be considered "at risk" of removal from the API.
+*/
+fz_pixmap *fz_render_glyph_pixmap(fz_context *ctx, fz_font *font, int gid, fz_matrix *ctm, const fz_irect *scissor, int aa);
+
+/**
+	Nasty PDF interpreter specific hernia, required to allow the
+	interpreter to replay glyphs from a type3 font directly into
+	the target device.
+
+	This is only used in exceptional circumstances (such as type3
+	glyphs that inherit current graphics state, or nested type3
+	glyphs).
+*/
+void fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gid, fz_matrix trm, void *gstate, fz_default_colorspaces *def_cs);
+
+/**
+	Force a type3 font to cache the displaylist for a given glyph
+	id.
+
+	This caching can involve reading the underlying file, so must
+	happen ahead of time, so we aren't suddenly forced to read the
+	file while playing a displaylist back.
+*/
+void fz_prepare_t3_glyph(fz_context *ctx, fz_font *font, int gid);
+
+/**
+	Dump debug statistics for the glyph cache.
+*/
+void fz_dump_glyph_cache_stats(fz_context *ctx, fz_output *out);
+
+/**
+	Perform subpixel quantisation and adjustment on a glyph matrix.
+
+	ctm: On entry, the desired 'ideal' transformation for a glyph.
+	On exit, adjusted to a (very similar) transformation quantised
+	for subpixel caching.
+
+	subpix_ctm: Initialised by the routine to the transform that
+	should be used to render the glyph.
+
+	qe, qf: which subpixel position we quantised to.
+
+	Returns: the size of the glyph.
+
+	Note: This is currently only exposed for use in our app. It
+	should be considered "at risk" of removal from the API.
+*/
+float fz_subpixel_adjust(fz_context *ctx, fz_matrix *ctm, fz_matrix *subpix_ctm, unsigned char *qe, unsigned char *qf);
+
+#endif

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/include/mupdf/fitz/glyph.h

@@ -0,0 +1,81 @@
+// Copyright (C) 2004-2021 Artifex Software, Inc.
+//
+// This file is part of MuPDF.
+//
+// MuPDF is free software: you can redistribute it and/or modify it under the
+// terms of the GNU Affero General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+// details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
+//
+// Alternative licensing terms are available from the licensor.
+// For commercial licensing, see <https://www.artifex.com/> or contact
+// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
+// CA 94129, USA, for further information.
+
+#ifndef MUPDF_FITZ_GLYPH_H
+#define MUPDF_FITZ_GLYPH_H
+
+#include "mupdf/fitz/system.h"
+#include "mupdf/fitz/context.h"
+#include "mupdf/fitz/geometry.h"
+#include "mupdf/fitz/store.h"
+#include "mupdf/fitz/font.h"
+#include "mupdf/fitz/path.h"
+
+/**
+	Glyphs represent a run length encoded set of pixels for a 2
+	dimensional region of a plane.
+*/
+typedef struct fz_glyph fz_glyph;
+
+/**
+	Return the bounding box of the glyph in pixels.
+*/
+fz_irect fz_glyph_bbox(fz_context *ctx, fz_glyph *glyph);
+fz_irect fz_glyph_bbox_no_ctx(fz_glyph *src);
+
+/**
+	Return the width of the glyph in pixels.
+*/
+int fz_glyph_width(fz_context *ctx, fz_glyph *glyph);
+
+/**
+	Return the height of the glyph in pixels.
+*/
+int fz_glyph_height(fz_context *ctx, fz_glyph *glyph);
+
+/**
+	Take a reference to a glyph.
+
+	pix: The glyph to increment the reference for.
+
+	Returns pix.
+*/
+fz_glyph *fz_keep_glyph(fz_context *ctx, fz_glyph *pix);
+
+/**
+	Drop a reference and free a glyph.
+
+	Decrement the reference count for the glyph. When no
+	references remain the glyph will be freed.
+*/
+void fz_drop_glyph(fz_context *ctx, fz_glyph *pix);
+
+/**
+	Look a glyph up from a font, and return the outline of the
+	glyph using the given transform.
+
+	The caller owns the returned path, and so is responsible for
+	ensuring that it eventually gets dropped.
+*/
+fz_path *fz_outline_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm);
+
+#endif

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/include/mupdf/fitz/hash.h

@@ -0,0 +1,126 @@
+// Copyright (C) 2004-2021 Artifex Software, Inc.
+//
+// This file is part of MuPDF.
+//
+// MuPDF is free software: you can redistribute it and/or modify it under the
+// terms of the GNU Affero General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+// details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
+//
+// Alternative licensing terms are available from the licensor.
+// For commercial licensing, see <https://www.artifex.com/> or contact
+// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
+// CA 94129, USA, for further information.
+
+#ifndef MUPDF_FITZ_HASH_H
+#define MUPDF_FITZ_HASH_H
+
+#include "mupdf/fitz/system.h"
+#include "mupdf/fitz/context.h"
+#include "mupdf/fitz/output.h"
+
+#define FZ_HASH_TABLE_KEY_LENGTH 48
+
+/**
+	Generic hash-table with fixed-length keys.
+
+	The keys and values are NOT reference counted by the hash table.
+	Callers are responsible for taking care the reference counts are
+	correct. Inserting a duplicate entry will NOT overwrite the old
+	value, and will return the old value.
+
+	The drop_val callback function is only used to release values
+	when the hash table is destroyed.
+*/
+
+typedef struct fz_hash_table fz_hash_table;
+
+/**
+	Function type called when a hash table entry is dropped.
+
+	Only used when the entire hash table is dropped.
+*/
+typedef void (fz_hash_table_drop_fn)(fz_context *ctx, void *val);
+
+/**
+	Create a new hash table.
+
+	initialsize: The initial size of the hashtable. The hashtable
+	may grow (double in size) if it starts to get crowded (80%
+	full).
+
+	keylen: byte length for each key.
+
+	lock: -1 for no lock, otherwise the FZ_LOCK to use to protect
+	this table.
+
+	drop_val: Function to use to destroy values on table drop.
+*/
+fz_hash_table *fz_new_hash_table(fz_context *ctx, int initialsize, int keylen, int lock, fz_hash_table_drop_fn *drop_val);
+
+/**
+	Destroy the hash table.
+
+	Values are dropped using the drop function.
+*/
+void fz_drop_hash_table(fz_context *ctx, fz_hash_table *table);
+
+/**
+	Search for a matching hash within the table, and return the
+	associated value.
+*/
+void *fz_hash_find(fz_context *ctx, fz_hash_table *table, const void *key);
+
+/**
+	Insert a new key/value pair into the hash table.
+
+	If an existing entry with the same key is found, no change is
+	made to the hash table, and a pointer to the existing value is
+	returned.
+
+	If no existing entry with the same key is found, ownership of
+	val passes in, key is copied, and NULL is returned.
+*/
+void *fz_hash_insert(fz_context *ctx, fz_hash_table *table, const void *key, void *val);
+
+/**
+	Remove the entry for a given key.
+
+	The value is NOT freed, so the caller is expected to take care
+	of this.
+*/
+void fz_hash_remove(fz_context *ctx, fz_hash_table *table, const void *key);
+
+/**
+	Callback function called on each key/value pair in the hash
+	table, when fz_hash_for_each is run.
+*/
+typedef void (fz_hash_table_for_each_fn)(fz_context *ctx, void *state, void *key, int keylen, void *val);
+
+/**
+	Iterate over the entries in a hash table.
+*/
+void fz_hash_for_each(fz_context *ctx, fz_hash_table *table, void *state, fz_hash_table_for_each_fn *callback);
+
+/**
+	Callback function called on each key/value pair in the hash
+	table, when fz_hash_filter is run to remove entries where the
+	callback returns true.
+*/
+typedef int (fz_hash_table_filter_fn)(fz_context *ctx, void *state, void *key, int keylen, void *val);
+
+/**
+	Iterate over the entries in a hash table, removing all the ones where callback returns true.
+	Does NOT free the value of the entry, so the caller is expected to take care of this.
+*/
+void fz_hash_filter(fz_context *ctx, fz_hash_table *table, void *state, fz_hash_table_filter_fn *callback);
+
+#endif

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/include/mupdf/fitz/heap-imp.h

@@ -0,0 +1,163 @@
+// Copyright (C) 2004-2022 Artifex Software, Inc.
+//
+// This file is part of MuPDF.
+//
+// MuPDF is free software: you can redistribute it and/or modify it under the
+// terms of the GNU Affero General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+// details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
+//
+// Alternative licensing terms are available from the licensor.
+// For commercial licensing, see <https://www.artifex.com/> or contact
+// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
+// CA 94129, USA, for further information.
+
+/* This file has preprocessor magic in it to instantiate both
+ * protoypes and implementations for heap sorting structures
+ * of various different types. Effectively, it's templating for
+ * C.
+ *
+ * If you are including this file directly without intending to
+ * be instantiating a new set of heap sort functions, you are
+ * doing the wrong thing.
+ */
+
+#ifndef MUPDF_FITZ_HEAP_I_KNOW_WHAT_IM_DOING
+#error Do not include heap-imp.h unless you know what youre doing
+#endif
+
+#define HEAP_XCAT(A,B) A##B
+#define HEAP_CAT(A,B) HEAP_XCAT(A,B)
+
+#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
+typedef struct
+{
+  int max;
+  int len;
+  HEAP_CONTAINER_TYPE *heap;
+} HEAP_TYPE_NAME;
+#endif
+
+void HEAP_CAT(HEAP_TYPE_NAME,_insert)(fz_context *ctx, HEAP_TYPE_NAME *heap, HEAP_CONTAINER_TYPE v
+#ifndef HEAP_CMP
+				, int (*HEAP_CMP)(HEAP_CONTAINER_TYPE *a, HEAP_CONTAINER_TYPE *b)
+#endif
+				)
+#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
+;
+#else
+{
+	int i;
+	HEAP_CONTAINER_TYPE *h;
+
+	if (heap->max == heap->len)
+	{
+		int m = heap->max * 2;
+
+		if (m == 0)
+			m = 32;
+
+		heap->heap = (HEAP_CONTAINER_TYPE *)fz_realloc(ctx, heap->heap, sizeof(*heap->heap) * m);
+		heap->max = m;
+	}
+	h = heap->heap;
+
+	/* Insert it into the heap. Consider inserting at position i, and
+	 * then 'heapify' back. We can delay the actual insertion to the
+	 * end of the process. */
+	i = heap->len++;
+	while (i != 0)
+	{
+		int parent_idx = (i-1)/2;
+		HEAP_CONTAINER_TYPE *parent_val = &h[parent_idx];
+		if (HEAP_CMP(parent_val, &v) > 0)
+			break;
+		h[i] = h[parent_idx];
+		i = parent_idx;
+	}
+	h[i] = v;
+}
+#endif
+
+void HEAP_CAT(HEAP_TYPE_NAME,_sort)(fz_context *ctx, HEAP_TYPE_NAME *heap
+#ifndef HEAP_CMP
+				, int (*HEAP_CMP)(HEAP_CONTAINER_TYPE *a, HEAP_CONTAINER_TYPE *b)
+#endif
+				)
+#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
+;
+#else
+{
+	int j;
+	HEAP_CONTAINER_TYPE *h = heap->heap;
+
+	/* elements j to len are always sorted. 0 to j are always a valid heap. Gradually move j to 0. */
+	for (j = heap->len-1; j > 0; j--)
+	{
+		int k;
+		HEAP_CONTAINER_TYPE val;
+
+		/* Swap max element with j. Invariant valid for next value to j. */
+		val = h[j];
+		h[j] = h[0];
+		/* Now reform the heap. 0 to k is a valid heap. */
+		k = 0;
+		while (1)
+		{
+			int kid = k*2+1;
+			if (kid >= j)
+				break;
+			if (kid+1 < j && (HEAP_CMP(&h[kid+1], &h[kid])) > 0)
+				kid++;
+			if ((HEAP_CMP(&val, &h[kid])) > 0)
+				break;
+			h[k] = h[kid];
+			k = kid;
+		}
+		h[k] = val;
+	}
+}
+#endif
+
+void HEAP_CAT(HEAP_TYPE_NAME,_uniq)(fz_context *ctx, HEAP_TYPE_NAME *heap
+#ifndef HEAP_CMP
+				, int (*HEAP_CMP)(HEAP_CONTAINER_TYPE *a, HEAP_CONTAINER_TYPE *b)
+#endif
+				)
+#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
+;
+#else
+{
+	int n = heap->len;
+	int i, j = 0;
+	HEAP_CONTAINER_TYPE *h = heap->heap;
+
+	if (n == 0)
+		return;
+
+	j = 0;
+	for (i = 1; i < n; i++)
+	{
+		if (HEAP_CMP(&h[j], &h[i]) == 0)
+			continue;
+		j++;
+		if (i != j)
+			h[j] = h[i];
+	}
+	heap->len = j+1;
+}
+#endif
+
+#undef HEAP_CONTAINER_TYPE
+#undef HEAP_TYPE_NAME
+#undef HEAP_CMP
+#undef HEAP_XCAT
+#undef HEAP_CAT