muhammara 2.0.0 → 2.3.0

package/node_modules/strip-ansi/readme.md

@@ -1,6 +1,6 @@
 # strip-ansi [![Build Status](https://travis-ci.org/chalk/strip-ansi.svg?branch=master)](https://travis-ci.org/chalk/strip-ansi)
 
-> Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code)
+> Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from a string
 
 
 ## Install
@@ -17,12 +17,23 @@ const stripAnsi = require('strip-ansi');
 
 stripAnsi('\u001B[4mUnicorn\u001B[0m');
 //=> 'Unicorn'
+
+stripAnsi('\u001B]8;;https://github.com\u0007Click\u001B]8;;\u0007');
+//=> 'Click'
 ```
 
 
+## strip-ansi for enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of strip-ansi and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-strip-ansi?utm_source=npm-strip-ansi&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+
+
 ## Related
 
 - [strip-ansi-cli](https://github.com/chalk/strip-ansi-cli) - CLI for this module
+- [strip-ansi-stream](https://github.com/chalk/strip-ansi-stream) - Streaming version of this module
 - [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes
 - [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes
 - [chalk](https://github.com/chalk/chalk) - Terminal string styling done right
@@ -33,7 +44,3 @@ stripAnsi('\u001B[4mUnicorn\u001B[0m');
 - [Sindre Sorhus](https://github.com/sindresorhus)
 - [Josh Junon](https://github.com/qix-)
 
-
-## License
-
-MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muhammara",
-  "version": "2.0.0",
+  "version": "2.3.0",
   "description": "Create, read and modify PDF files and streams. A drop in replacement for hummujs PDF library",
   "homepage": "https://github.com/julianhille/Muhammarajs",
   "license": "Apache-2.0",

package/src/DocumentCopyingContextDriver.cpp

@@ -156,7 +156,7 @@ METHOD_RETURN_TYPE DocumentCopyingContextDriver::CreateFormXObjectFromPDFPage(co
     
     if(result.first != eSuccess)
     {
-		THROW_EXCEPTION("Unable to create form xobject from PDF page, parhaps the page index does not fit the total pages count");
+		THROW_EXCEPTION("Unable to create form xobject from PDF page, perhaps the page index does not fit the total pages count");
         SET_FUNCTION_RETURN_VALUE(UNDEFINED)
     }
     
@@ -191,7 +191,7 @@ METHOD_RETURN_TYPE DocumentCopyingContextDriver::MergePDFPageToPage(const ARGS_T
                                                                                   TO_UINT32(args[1])->Value());
     
     if(status != eSuccess)
-		THROW_EXCEPTION("Unable to merge page index to page. parhaps the page index is wrong");
+		THROW_EXCEPTION("Unable to merge page index to page. Perhaps the page index is wrong");
     SET_FUNCTION_RETURN_VALUE(UNDEFINED)
 
 }
@@ -220,7 +220,7 @@ METHOD_RETURN_TYPE DocumentCopyingContextDriver::AppendPDFPageFromPDF(const ARGS
     
     if(result.first != eSuccess)
     {
-		THROW_EXCEPTION("Unable to append page. parhaps the page index is wrong");
+		THROW_EXCEPTION("Unable to append page. Perhaps the page index is wrong");
         SET_FUNCTION_RETURN_VALUE(UNDEFINED)
     }
     
@@ -255,7 +255,7 @@ METHOD_RETURN_TYPE DocumentCopyingContextDriver::MergePDFPageToFormXObject(const
                                                                                   TO_UINT32(args[1])->Value());
     
     if(status != eSuccess)
-		THROW_EXCEPTION("Unable to merge page index to form. parhaps the page index is wrong");
+		THROW_EXCEPTION("Unable to merge page index to form. Perhaps the page index is wrong");
     SET_FUNCTION_RETURN_VALUE(UNDEFINED)
 
 }
@@ -293,7 +293,7 @@ METHOD_RETURN_TYPE DocumentCopyingContextDriver::CopyDirectObjectAsIs(const ARGS
     
     EStatusCode status = copyingContextDriver->CopyingContext->CopyDirectObjectAsIs(ObjectWrap::Unwrap<PDFObjectDriver>(args[0]->TO_OBJECT())->GetObject());
     if(status != eSuccess)
-		THROW_EXCEPTION("Unable to merge page index to form. parhaps the page index is wrong");
+		THROW_EXCEPTION("Unable to merge page index to form. Perhaps the page index is wrong");
     SET_FUNCTION_RETURN_VALUE(UNDEFINED)
     
 }
@@ -347,7 +347,7 @@ METHOD_RETURN_TYPE DocumentCopyingContextDriver::CopyDirectObjectWithDeepCopy(co
     
     EStatusCodeAndObjectIDTypeList result = copyingContextDriver->CopyingContext->CopyDirectObjectWithDeepCopy(ObjectWrap::Unwrap<PDFObjectDriver>(args[0]->TO_OBJECT())->GetObject());
     if(result.first != eSuccess)
-		THROW_EXCEPTION("Unable to copy object, parhaps the object id is wrong");
+		THROW_EXCEPTION("Unable to copy object, perhaps the object id is wrong");
 
     Local<Array> resultObjectIDs = NEW_ARRAY((unsigned int)result.second.size());
     unsigned int index = 0;

package/src/deps/PDFWriter/CMakeLists.txt

@@ -80,6 +80,7 @@ InputDCTDecodeStream.cpp
 InputFile.cpp
 InputFileStream.cpp
 InputFlateDecodeStream.cpp
+InputLZWDecodeStream.cpp
 InputLimitedStream.cpp
 InputRC4XcodeStream.cpp
 InputPFBDecodeStream.cpp
@@ -206,6 +207,7 @@ CIDFontWriter.h
 CMYKRGBColor.h
 ContainerIterator.h
 DecryptionHelper.h
+Deletable.h
 DescendentFontWriter.h
 DictionaryContext.h
 DictOperand.h
@@ -233,6 +235,7 @@ IByteReaderWithPosition.h
 IByteWriter.h
 IByteWriterWithPosition.h
 IContentContextListener.h
+IDeletable.h
 IDescendentFontWriter.h
 IDocumentContextExtender.h
 IFontDescriptorHelper.h
@@ -251,6 +254,7 @@ InputDCTDecodeStream.h
 InputFile.h
 InputFileStream.h
 InputFlateDecodeStream.h
+InputLZWDecodeStream.h
 InputLimitedStream.h
 InputRC4XcodeStream.h
 InputPFBDecodeStream.h
@@ -553,6 +557,8 @@ InputFileStream.cpp
 InputFileStream.h
 InputFlateDecodeStream.cpp
 InputFlateDecodeStream.h
+InputLZWDecodeStream.cpp
+InputLZWDecodeStream.h
 InputLimitedStream.cpp
 InputLimitedStream.h
 InputRC4XcodeStream.cpp
@@ -636,6 +642,8 @@ UppercaseSequance.h
 )
 
 source_group("PDF Embedding\\Parsed Objects" FILES
+Deletable.h
+IDeletable.h
 PDFArray.cpp
 PDFArray.h
 PDFBoolean.cpp

package/src/deps/PDFWriter/DecryptionHelper.cpp

@@ -36,6 +36,7 @@ limitations under the License.
 #include "InputRC4XcodeStream.h"
 #include "InputAESDecodeStream.h"
 #include "Trace.h"
+#include "Deletable.h"
 #include <memory>
 
 using namespace std;
@@ -333,9 +334,9 @@ IByteReader* DecryptionHelper::CreateDefaultDecryptionFilterForStream(PDFStreamI
 	if (!IsEncrypted() || !CanDecryptDocument() || HasCryptFilterDefinition(mParser, inStream) || !mXcryptStreams)
 		return NULL;
 	
-	void* savedEcnryptionKey = inStream->GetMetadata(scEcnryptionKeyMetadataKey);
+	IDeletable* savedEcnryptionKey = inStream->GetMetadata(scEcnryptionKeyMetadataKey);
 	if (savedEcnryptionKey) {
-		return CreateDecryptionReader(inToWrapStream, *((ByteList*)savedEcnryptionKey), mXcryptStreams->IsUsingAES());
+		return CreateDecryptionReader(inToWrapStream, *(((Deletable<ByteList>*)savedEcnryptionKey)->GetPtr()), mXcryptStreams->IsUsingAES());
 	}
 	else 
 		return NULL;
@@ -346,7 +347,7 @@ IByteReader*  DecryptionHelper::CreateDecryptionFilterForStream(PDFStreamInput*
 	if (!IsEncrypted() || !CanDecryptDocument())
 		return inToWrapStream;
 
-	void* savedEcnryptionKey = inStream->GetMetadata(scEcnryptionKeyMetadataKey);
+	IDeletable* savedEcnryptionKey = inStream->GetMetadata(scEcnryptionKeyMetadataKey);
 	if (!savedEcnryptionKey) {
 		// sign for no encryption here
 		return inToWrapStream;
@@ -354,7 +355,7 @@ IByteReader*  DecryptionHelper::CreateDecryptionFilterForStream(PDFStreamInput*
 	XCryptionCommon* xcryption = GetFilterForName(mXcrypts, inCryptName);
 
 	if (xcryption && savedEcnryptionKey) {
-		return CreateDecryptionReader(inToWrapStream, *((ByteList*)savedEcnryptionKey), xcryption->IsUsingAES());
+		return CreateDecryptionReader(inToWrapStream, *(((Deletable<ByteList>*)savedEcnryptionKey)->GetPtr()), xcryption->IsUsingAES());
 	}
 	else
 		return inToWrapStream;
@@ -369,12 +370,13 @@ std::string DecryptionHelper::DecryptString(const std::string& inStringToDecrypt
 	if (!IsDecrypting() || !mXcryptStrings)
 		return inStringToDecrypt;
 
-	std::auto_ptr<IByteReader> pDecryptStream(CreateDecryptionReader(new InputStringStream(inStringToDecrypt), mXcryptStrings->GetCurrentObjectKey(), mXcryptStrings->IsUsingAES()));
-	if (pDecryptStream.get()) {
+	IByteReader* decryptStream = CreateDecryptionReader(new InputStringStream(inStringToDecrypt), mXcryptStrings->GetCurrentObjectKey(), mXcryptStrings->IsUsingAES());
+	if (decryptStream) {
 		OutputStringBufferStream outputStream;
 		OutputStreamTraits traits(&outputStream);
-		traits.CopyToOutputStream(pDecryptStream.get());
+		traits.CopyToOutputStream(decryptStream);
 
+		delete decryptStream;
 		return outputStream.ToString();
 	}
 	else
@@ -453,7 +455,7 @@ void DecryptionHelper::OnObjectEnd(PDFObject* inObject) {
 		XCryptionCommon* streamCryptFilter = GetCryptForStream((PDFStreamInput*)inObject);
 		if (streamCryptFilter) {
 			ByteList* savedKey = new ByteList(streamCryptFilter->GetCurrentObjectKey());
-			inObject->SetMetadata(scEcnryptionKeyMetadataKey, savedKey);
+			inObject->SetMetadata(scEcnryptionKeyMetadataKey,new Deletable<ByteList>(savedKey));
 		}
 	}
 

package/src/deps/PDFWriter/Deletable.h

@@ -0,0 +1,46 @@
+#include "IDeletable.h"
+
+template <typename T>
+class Deletable: public IDeletable {
+public:
+    Deletable(T* inData);
+    virtual ~Deletable();
+
+    virtual void DeleteMe();
+
+    T* operator->();
+
+	T* GetPtr();
+private:
+    T* mValue;
+};
+
+template <typename T>
+Deletable<T>::Deletable(T* inValue)
+{
+	mValue = inValue;
+}
+
+template <typename T>
+Deletable<T>::~Deletable()
+{
+	delete mValue;
+}
+
+template <typename T>
+void Deletable<T>::DeleteMe()
+{
+	delete this;
+}
+
+template <typename T>
+T* Deletable<T>::operator->()
+{
+	return mValue;
+}
+
+template <typename T>
+T* Deletable<T>::GetPtr()
+{
+	return mValue;
+}

package/src/deps/PDFWriter/DocumentContext.h

@@ -283,9 +283,9 @@ namespace PDFHummus
 
 		// some public image info services, for users of hummus
 		DoubleAndDoublePair GetImageDimensions(const std::string& inImageFile,unsigned long inImageIndex = 0, const PDFParsingOptions& inOptions = PDFParsingOptions::DefaultPDFParsingOptions());
-    DoubleAndDoublePair GetImageDimensions(IByteReaderWithPosition* inImageStream,unsigned long inImageIndex = 0, const PDFParsingOptions& inOptions = PDFParsingOptions::DefaultPDFParsingOptions());
-    EHummusImageType GetImageType(const std::string& inImageFile,unsigned long inImageIndex);
-    EHummusImageType GetImageType(IByteReaderWithPosition* inImageStream,unsigned long inImageIndex);
+	    DoubleAndDoublePair GetImageDimensions(IByteReaderWithPosition* inImageStream,unsigned long inImageIndex = 0, const PDFParsingOptions& inOptions = PDFParsingOptions::DefaultPDFParsingOptions());
+		EHummusImageType GetImageType(const std::string& inImageFile,unsigned long inImageIndex);
+	    EHummusImageType GetImageType(IByteReaderWithPosition* inImageStream,unsigned long inImageIndex);
 		unsigned long GetImagePagesCount(const std::string& inImageFile, const PDFParsingOptions& inOptions = PDFParsingOptions::DefaultPDFParsingOptions());
 
 

package/src/deps/PDFWriter/IDeletable.h

@@ -0,0 +1,6 @@
+#pragma once
+
+class IDeletable {
+    public: 
+        virtual void DeleteMe() = 0;
+};

package/src/deps/PDFWriter/InputLZWDecodeStream.cpp

@@ -0,0 +1,208 @@
+/*
+   Source File : InputLZWDecodeStream.cpp
+
+
+   Copyright 2011 Gal Kahana PDFWriter
+
+   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.
+
+   
+*/
+#include "InputLZWDecodeStream.h"
+
+#include "Trace.h"
+#include "zlib.h"
+
+
+InputLZWDecodeStream::InputLZWDecodeStream(int early)
+{
+	mSourceStream = NULL;
+	mCurrentlyEncoding = false;
+	mEarly = early;
+	inputBuf = 0;
+}
+
+InputLZWDecodeStream::~InputLZWDecodeStream(void)
+{
+	if(mCurrentlyEncoding)
+		FinalizeEncoding();
+	if(mSourceStream)
+		delete mSourceStream;	
+}
+
+void InputLZWDecodeStream::FinalizeEncoding()
+{	
+	mCurrentlyEncoding = false;
+}
+
+InputLZWDecodeStream::InputLZWDecodeStream(IByteReader* inSourceReader)
+{	
+	mSourceStream = NULL;
+	mCurrentlyEncoding = false;
+
+	Assign(inSourceReader);
+}
+
+void InputLZWDecodeStream::Assign(IByteReader* inSourceReader)
+{
+	mSourceStream = inSourceReader;
+	if(mSourceStream)
+		StartEncoding();
+}
+
+void InputLZWDecodeStream::StartEncoding()
+{	
+    mCurrentlyEncoding = true;
+
+	inputBits = 0;
+	ClearTable();
+}
+
+IOBasicTypes::LongBufferSizeType InputLZWDecodeStream::Read(IOBasicTypes::Byte* inBuffer, IOBasicTypes::LongBufferSizeType inBufferSize)
+{
+	if (mCurrentlyEncoding)
+	{
+		if (seqIndex >= seqLength)
+		{
+			if (!ProcessNextCode())
+				return 0;
+		}
+		memcpy(inBuffer, &seqBuf[seqIndex], 1);
+		seqIndex++;
+		return 1;		
+	}
+	return 0;
+}
+
+bool InputLZWDecodeStream::ProcessNextCode() 
+{
+	int code;
+	int nextLength;
+	int i, j;
+
+	// check for EOF
+	bool ret = false;
+	do
+	{
+		if (!mCurrentlyEncoding)
+			break;
+		// check for eod and clear-table codes
+		do
+		{
+			code = GetCode();
+			if (code == -1 || code == 257)
+			{
+				mCurrentlyEncoding = false;
+				break;
+			}
+			if (code == 256)
+			{
+				ClearTable();				
+			}
+		} while (code == 256);
+
+		if(!mCurrentlyEncoding)
+			break;		
+
+		if (nextCode >= 4097) 
+		{
+			//error(getPos(), "Bad LZW stream - expected clear-table code");
+			ClearTable();
+		}
+
+		// process the next code
+		nextLength = seqLength + 1;
+		if (code < 256) 
+		{
+			seqBuf[0] = code;
+			seqLength = 1;
+		}
+		else if (code < nextCode) 
+		{
+			seqLength = table[code].length;
+			for (i = seqLength - 1, j = code; i > 0; --i) {
+				seqBuf[i] = table[j].tail;
+				j = table[j].head;
+			}
+			seqBuf[0] = j;
+		}
+		else if (code == nextCode) 
+		{
+			seqBuf[seqLength] = newChar;
+			++seqLength;
+		}
+		else 
+		{
+			//error(getPos(), "Bad LZW stream - unexpected code");
+			mCurrentlyEncoding = false;
+			break;
+		}
+		newChar = seqBuf[0];
+		if (first) {
+			first = false;
+		}
+		else {
+			table[nextCode].length = nextLength;
+			table[nextCode].head = prevCode;
+			table[nextCode].tail = newChar;
+			++nextCode;
+			if (nextCode + mEarly == 512)
+				nextBits = 10;
+			else if (nextCode + mEarly == 1024)
+				nextBits = 11;
+			else if (nextCode + mEarly == 2048)
+				nextBits = 12;
+		}
+		prevCode = code;
+
+		// reset buffer
+		seqIndex = 0;
+
+		ret = true;
+
+	} while (false);
+	return ret;
+}
+
+
+void InputLZWDecodeStream::ClearTable() {
+	nextCode = 258;
+	nextBits = 9;
+	seqIndex = seqLength = 0;
+	first = true;
+}
+
+int InputLZWDecodeStream::GetCode() {
+	int c;
+	int code;
+
+	IOBasicTypes::Byte buffer;
+	while (inputBits < nextBits) 
+	{
+		mSourceStream->Read(&buffer, 1);
+		c = buffer;
+
+		if (c == -1) return -1;
+		inputBuf = (inputBuf << 8) | (c & 0xff);
+		inputBits += 8;
+	}
+	code = (inputBuf >> (inputBits - nextBits)) & ((1 << nextBits) - 1);
+	inputBits -= nextBits;
+	inputBuf = inputBuf & ((1 << inputBits) - 1); // avoid overflow by limiting to the bits its supposed to use 
+	return code;
+}
+
+bool InputLZWDecodeStream::NotEnded()
+{
+	return mCurrentlyEncoding;
+}

package/src/deps/PDFWriter/InputLZWDecodeStream.h

@@ -0,0 +1,77 @@
+/*
+   Source File : InputLZWDecodeStream.h
+
+
+   Copyright 2011 Gal Kahana PDFWriter
+
+   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.
+
+   
+*/
+#pragma once
+
+#include "EStatusCode.h"
+#include "IByteReader.h"
+
+class InputLZWDecodeStream : public IByteReader
+{
+public:
+	InputLZWDecodeStream(int early);
+
+	// Note that assigning passes ownership on the stream, use Assign(NULL) to remove ownership
+	InputLZWDecodeStream(IByteReader* inSourceReader);
+	virtual ~InputLZWDecodeStream(void);
+
+	// Assigning passes ownership of the input stream to the decoder stream. 
+	// if you don't care for that, then after finishing with the decode, Assign(NULL).
+	void Assign(IByteReader* inSourceReader);
+
+	// IByteReader implementation. note that "inBufferSize" determines how many
+	// bytes will be placed in the Buffer...not how many are actually read from the underlying
+	// encoded stream. got it?!
+	virtual IOBasicTypes::LongBufferSizeType Read(IOBasicTypes::Byte* inBuffer,IOBasicTypes::LongBufferSizeType inBufferSize);
+
+	virtual bool NotEnded();
+
+private:
+	
+	IByteReader* mSourceStream;
+	
+	bool mCurrentlyEncoding;
+	
+	int mEarly;			// early parameter
+	int inputBuf;		// input buffer
+	int inputBits;		// number of bits in input buffer
+
+	struct {			// decoding table
+		int length;
+		int head;
+		IOBasicTypes::Byte tail;
+	} table[4097];
+	int nextCode;			// next code to be used
+	int nextBits;			// number of bits in next code word
+	int prevCode;			// previous code used in stream
+	int newChar;			// next char to be added to table
+	IOBasicTypes::Byte		seqBuf[4097];		// buffer for current sequence
+	int seqLength;		// length of current sequence
+	int seqIndex;			// index into current sequence
+	bool first;			// first code after a table clear
+
+	bool ProcessNextCode();
+	void ClearTable();
+	int GetCode();
+
+	void FinalizeEncoding();	
+	void StartEncoding();
+
+};

package/src/deps/PDFWriter/InputStreamSkipperStream.cpp

@@ -53,7 +53,7 @@ IOBasicTypes::LongBufferSizeType InputStreamSkipperStream::Read(IOBasicTypes::By
 
 bool InputStreamSkipperStream::NotEnded()
 {
-	return mStream->NotEnded();
+	return mStream ? mStream->NotEnded() : false;
 }
 
 

package/src/deps/PDFWriter/JPEGImageHandler.h

@@ -58,14 +58,14 @@ public:
 
 	// use this for retrieving image information for JPEG (useful for deciphering JPG dimensions tags)
 	BoolAndJPEGImageInformation RetrieveImageInformation(const std::string& inJPGFilePath);
-  BoolAndJPEGImageInformation RetrieveImageInformation(IByteReaderWithPosition* inJPGStream);
+	BoolAndJPEGImageInformation RetrieveImageInformation(IByteReaderWithPosition* inJPGStream);
 
 	// DocumentContext::CreateImageXObjectFromJPGFile are equivelent
 	PDFImageXObject* CreateImageXObjectFromJPGFile(const std::string& inJPGFilePath);
 	PDFImageXObject* CreateImageXObjectFromJPGStream(IByteReaderWithPosition* inJPGStream);
 	PDFImageXObject* CreateImageXObjectFromJPGFile(const std::string& inJPGFilePath,ObjectIDType inImageXObjectID);
 	PDFImageXObject* CreateImageXObjectFromJPGStream(IByteReaderWithPosition* inJPGStream,ObjectIDType inImageXObjectID);
-
+	
 	// will return form XObject, which will include the xobject at it's size
 	PDFFormXObject* CreateFormXObjectFromJPGFile(const std::string& inJPGFilePath);
 	PDFFormXObject* CreateFormXObjectFromJPGStream(IByteReaderWithPosition* inJPGStream);

package/src/deps/PDFWriter/ObjectsContext.cpp

@@ -378,6 +378,11 @@ void ObjectsContext::SetCompressStreams(bool inCompressStreams)
 	mCompressStreams = inCompressStreams;
 }
 
+bool ObjectsContext::IsCompressingStreams()
+{
+	return mCompressStreams;
+}
+
 static const std::string scLength = "Length";
 static const std::string scStream = "stream";
 static const std::string scEndStream = "endstream";

package/src/deps/PDFWriter/ObjectsContext.h

@@ -114,6 +114,7 @@ public:
 
 	// Sets whether streams created by the objects context will be compressed (with flate) or not
 	void SetCompressStreams(bool inCompressStreams);
+	bool IsCompressingStreams();
 
 	// Create PDF stream and write it's header. note that stream are written with indirect object for Length, to allow one pass writing.
 	// inStreamDictionary can be passed in order to include stream generic information in an already written stream dictionary

package/src/deps/PDFWriter/PDFDocumentHandler.cpp

@@ -2018,9 +2018,24 @@ EStatusCode PDFDocumentHandler::WriteStreamObject(PDFStreamInput* inStream, IObj
 
 	MapIterator<PDFNameToPDFObjectMap> it(streamDictionary->GetIterator());
 	EStatusCode status = PDFHummus::eSuccess;
+	bool readingDecrypted = false;
+	IByteReader* streamReader = NULL;
+
+	/*
+	*	To support unencrypted pdf output, mostly used for debugging, (and maybe i should put a general flag there),
+	*	add ability here to copy by rewriting the streams...when possible.
+	*/
+	if(!mObjectsContext->IsCompressingStreams()) {
+		streamReader = mParser->StartReadingFromStream(inStream);
+		readingDecrypted = streamReader != NULL;
+	}	
+	if(!readingDecrypted) {
+		streamReader = mParser->StartReadingFromStreamForPlainCopying(inStream);
+	}
+	
 	while (it.MoveNext() && PDFHummus::eSuccess == status)
 	{
-		if (it.GetKey()->GetValue() != "Length") {
+		if (it.GetKey()->GetValue() != "Length" && (!readingDecrypted || it.GetKey()->GetValue() != "Filter")) {
 			status = newStreamDictionary->WriteKey(it.GetKey()->GetValue());
 			if (PDFHummus::eSuccess == status)
 				status = WriteObjectByType(it.GetValue(), eTokenSeparatorEndLine, inWritePolicy);
@@ -2033,9 +2048,10 @@ EStatusCode PDFDocumentHandler::WriteStreamObject(PDFStreamInput* inStream, IObj
 		return PDFHummus::eFailure;
 	}
 
-	PDFStream* newStream = mObjectsContext->StartUnfilteredPDFStream(newStreamDictionary);
+	PDFStream* newStream = readingDecrypted ?
+		mObjectsContext->StartPDFStream(newStreamDictionary) :
+		mObjectsContext->StartUnfilteredPDFStream(newStreamDictionary);
 	OutputStreamTraits outputTraits(newStream->GetWriteStream());
-	IByteReader* streamReader = mParser->StartReadingFromStreamForPlainCopying(inStream);
 
 	status = outputTraits.CopyToOutputStream(streamReader);
 	if (status != PDFHummus::eSuccess)