pdf viewer in asp net c# : Add signature image to pdf software SDK dll winforms windows html web forms PowerGREP30-part3051

296 
Perl (but not PCRE) and Java support the «
\p{IsL}
» notation, prefixing one-letter and two-letter Unicode 
property notations with ´Isµ. Since very few regex flavors support the «
\p{IsL}
» notation, and all Unicode-
compatible regex flavors (including Perl and Java) support «
\p{L}
», I strongly recommend you use the latter 
syntax. 
Perl and Java allow you to omit the ´Inµ when matching Unicode blocks, so you can write «
\p{Arrows}
» 
instead of «
\p{InArrows}
». Perl can also match Unicode scripts, and some scripts like ´Hebrewµ have the 
same name as a Unicode block. In that situation, Perl will match the Hebrew script instead of the Hebrew 
block when you write «
\p{Hebrew}
». While there are no Unicode properties with the same names as blocks, 
the property «
\p{Currency_Symbol}
» is confusingly similar to the block «
\p{Currency}
». As I explained 
in the section on Unicode blocks, the characters they match are quite different. To avoid all such confusion, I 
strongly recommend you use the ´Inµ syntax for blocks, the ´Isµ syntax for scripts (if supported), and the 
shorthand syntax «
\p{Lu}
» for properties. 
Again, the JGsoft engine supports all of the above oddball notations. This is only done to allow you to copy 
and paste regular expressions and have them work as they do in Perl or Java. You should consider these 
notations deprecated. 
Do You Need To Worry About Different Encodings? 
While you should always keep in mind the pitfalls created by the different ways in which accented characters 
can be encoded, you don’t always have to worry about them. If you know that your input string and your 
regex use the same style, then you don’t have to worry about it at all. This process is called Unicode 
normalization. All programming languages with native Unicode support, such as Java, C# and VB.NET, have 
library routines for normalizing strings. If you normalize both the subject and regex before attempting the 
match, there won’t be any inconsistencies. 
If you are using Java, you can pass the CANON_EQ flag as the second parameter to Pattern.compile(). This 
tells the Java regex engine to consider canonically equivalent characters as identical. E.g. the regex «
à
» encoded as 
U+00E0 will match „
à
µ encoded as U+0061 U+0300, and vice versa. None of the other regex engines 
currently support canonical equivalence while matching. 
If you type the à key on the keyboard, all word processors that I know of will insert the code point U+00E0 
into the file. So if you’re working with text that you typed in yourself, any regex that you type in yourself will 
match in the same way. 
Finally, if you’re using PowerGREP to search through text files encoded using a traditional Windows (often 
called ´ANSIµ) or ISO-8859 code page, PowerGREP will always use the one-on-one substitution. Since all 
the Windows or ISO-8859 code pages encode accented characters as a single code point, all software that I 
know of will use a single Unicode code point for each character when converting the file to Unicode. 
Add signature image to pdf - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
add jpg to pdf; add jpg to pdf online
Add signature image to pdf - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
adding image to pdf form; add image to pdf file
297 
15. Regex Matching Modes 
Most regular expression engines discussed in this tutorial support the following four matching modes: 
/i
makes the regex match case insensitive.  
/s
enables "single-line mode". In this mode, the dot matches newlines.  
/m
enables "multi-line mode". In this mode, the caret and dollar match before and after newlines in 
the subject string.  
/x
enables ´free-spacing modeµ. In this mode, whitespace between regex tokens is ignored, and an 
unescaped # starts a comment.  
Two languages that don’t support all of the above four are JavaScript and Ruby. Some regex flavors also have 
additional modes or options that have single letter equivalents. These are very implementation-dependent. 
Most tools that support regular expressions have checkboxes or similar controls that you can use to turn 
these modes on or off. Most programming languages allow you to pass option flags when constructing the 
regex object. E.g. in Perl, 
m/regex/i
turns on case insensitivity, while 
Pattern.compile("regex", 
Pattern.CASE_INSENSITIVE)
does the same in Java. 
Specifying Modes Inside The Regular Expression 
Sometimes, the tool or language does not provide the ability to specify matching options. E.g. the handy 
String.matches()
method  in  Java  does  not  take  a  parameter  for  matching  options  like 
Pattern.compile()
does. 
In that situation, you can add a mode modifier to the start of the regex. E.g. 
(?i)
turns on case insensitivity, 
while 
(?ism)
turns on all three options. 
Turning Modes On and Off for Only Part of The Regular Expression 
Modern regex flavors allow you to apply modifiers to only part of the regular expression. If you insert the 
modifier 
(?ism)
in the middle of the regex, the modifier only applies to the part of the regex to the right of 
the modifier. You can turn off modes by preceding them with a minus sign. All modes after the minus sign 
will be turned off. E.g. 
(?i-sm)
turns on case insensitivity, and turns off both single-line mode and multi-
line mode. 
Not all regex flavors support this. JavaScript and Python apply all mode modifiers to the entire regular 
expression. They don’t support the 
(?-ismx)
syntax, since turning off an option is pointless when mode 
modifiers apply to the whole regular expressions. All options are off by default. 
You can quickly test how the regex flavor you’re using handles mode modifiers. The regex «
(?i)te(?-
i)st
» should match „
test
µ and „
TEst
µ, but not ´
teST
µ or ´
TEST
µ. 
C# PDF Digital Signature Library: add, remove, update PDF digital
Verify the validity of PDF signature. Add necessary references CHINA SHANGHAI"; cert.Reason = "Reason"; cert.APMode = APMode.Text; // APMode.Text | APMode.Image.
add image to pdf reader; add photo to pdf form
VB.NET PDF Digital Signature Library: add, remove, update PDF
Verify the validity of PDF signature. Add necessary references: CHINA SHANGHAI" cert.Reason = "Reason" cert.APMode = APMode.Text ' APMode.Text | APMode.Image.
add jpg to pdf form; attach image to pdf form
298 
Modifier Spans 
Instead of using two modifiers, one to turn an option on, and one to turn it off, you use a modifier span. 
«
(?i)ignorecase(?-i)casesensitive(?i)ignorecase
»  is  equivalent  to  «
(?i)ignorecase(?-
i:casesensitive)ignorecase
». You have probably noticed the resemblance between the modifier span 
and the non-capturing group «
(?:group)
». Technically, the non-capturing group is a modifier span that does 
not change any modifiers. It is obvious that the modifier span does not create a backreference. 
Modifier spans are supported by all regex flavors that allow you to use mode modifiers in the middle of the 
regular expression, and by those flavors only. These include the JGsoft engine, .NET, Java, Perl and PCRE. 
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
convert PDF to multi-page Tiff image files and to PDF, including freehand signature, text and date signature. If you need to add your own signatures such as
how to add a picture to a pdf document; adding a jpg to a pdf
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Tiff
For examples, add text signature to Tiff image, insert date signature to Tiff or create freehand signature to Tiff.
add jpg to pdf file; add image in pdf using java
299 
16. Possessive Quantifiers 
When discussing the repetition operators or quantifiers, I explained the difference between greedy and lazy 
repetition.  Greediness  and  laziness  determine  the  order  in  which  the  regex  engine  tries  the  possible 
permutations of the regex pattern. A greedy quantifier will first try to repeat the token as many times as 
possible, and gradually give up matches as the engine backtracks to find an overall match. A lazy quantifier 
will first repeat the token as few times as required, and gradually expand the match as the engine backtracks 
through the regex to find an overall match. 
Because greediness and laziness change the order in which permutations are tried, they can change the overall 
regex match. However, they do not change the fact that the regex engine will backtrack to try all possible 
permutations of the regular expression in case no match can be found. 
Possessive quantifiers are a way to prevent the regex engine from trying all permutations. This is primarily 
useful for performance reasons. You can also use possessive quantifiers to eliminate certain matches. 
How Possessive Quantifiers Work 
Several  modern regular expression flavors, including the JGsoft, Java and PCRE have a  third kind  of 
quantifier: the possessive quantifier. Like a greedy quantifier, a possessive quantifier will repeat the token as 
many times as possible. Unlike a greedy quantifier, it will not give up matches as the engine backtracks. With a 
possessive quantifier, the deal is all or nothing. You can make a quantifier possessive by placing an extra 
+
after it. E.g. «
*
» is greedy, «
*?
» is lazy, and «
*+
» is possessive. «
++
», «
?+
» and «
{n,m}+
» are all possessive as 
well. 
Let’s see what happens if we try to match «
"[^"]*+"
» against ´
"abc"
µ. The «
"
» matches the „
"
µ. «
[^"]
» 
matches „
a
µ, „
b
µ and „
c
µ as it is repeated by the star. The final «
"
» then matches the final „
"
µ and we found 
an overall match. In this case, the end result is the same, whether we use a greedy or possessive quantifier. 
There is a slight performance increase though, because the possessive quantifier doesn’t have to remember 
any backtracking positions. 
The performance increase can be significant in situations where the regex fails. If the subject is ´
"abc
µ (no 
closing quote), the above matching process will happen in the same way, except that the second «
"
» fails. 
When using a possessive quantifier, there are no steps to backtrack to. The regular expression does not have 
any  alternation  or  non-possessive  quantifiers that  can  give  up  part  of  their  match  to  try  a  different 
permutation of the regular expression. So the match attempt fails immediately when the second «
"
» fails. 
Had we used a greedy quantifier instead, the engine would have backtracked. After the «
"
» failed at the end of 
the string, the «
[^"]*
» would give up one match, leaving it with „
ab
µ. The «
"
» would then fail to match ´
c
µ. 
«
[^"]*
» backtracks to just „
a
µ, and «
"
» fails to match ´
b
µ. Finally, «
[^"]*
» backtracks to match zero 
characters, and «
"
» fails ´
a
µ. Only at this point have all backtracking positions been exhausted, and does the 
engine give up the match attempt. Essentially, this regex performs as many needless steps as there are 
characters following the unmatched opening quote. 
C# WPF Viewer: Load, View, Convert, Annotate and Edit Tiff
users can perform Tiff viewing and multiple Tiff image manipulation functionalities. convert Tiff file to PDF, add annotations to Tiff, Create signature on tiff
adding image to pdf in preview; add png to pdf acrobat
C# WinForms Viewer: Load, View, Convert, Annotate and Edit Tiff
load Tiff to WinForms Viewer easily and view Tiff image on it in preview, such as convert Tiff file to PDF, add annotations to Tiff, Create signature on tiff
add an image to a pdf form; adding image to pdf file
300 
When Possessive Quantifiers Matter 
The main practical benefit of possessive quantifiers is to speed up your regular expression. In particular, 
possessive quantifiers allow your regex to fail faster. In the above example, when the closing quote fails to 
match, we know the regular expression couldn’t have possibly skipped over a quote. So there’s no need to 
backtrack and check for the quote. We make the regex engine aware of this by making the quantifier 
possessive. In fact, some engines, including the JGsoft engine detect that «
[^"]*
» and «
"
» are mutually 
exclusive when compiling your regular expression, and automatically make the star possessive. 
Now, linear backtracking like a regex with a single quantifier does is pretty fast. It’s unlikely you’ll notice the 
speed difference. However, when you’re nesting quantifiers, a possessive quantifier may save your day. 
Nesting quantifiers means that you have one or more repeated tokens inside a group, and the group is also 
repeated. That’s when catastrophic backtracking often rears its ugly head. In such cases, you’ll depend on 
possessive quantifiers and/or atomic grouping to save the day. 
Possessive Quantifiers Can Change The Match Result 
Using possessive quantifiers can change the result of a match attempt. Since no backtracking is done, and 
matches that would require a greedy quantifier to backtrack will not be found with a possessive quantifier. 
E.g. «
".*"
» will match „
"abc"
µ in ´
"abc"x
µ, but «
".*+"
» will not match this string at all. 
In both regular expressions, the first «
"
» will match the first „
"
µ in the string. The repeated dot then matches 
the remainder of the string „
abc"x
µ. The second «
"
» then fails to match at the end of the string. 
Now, the paths of the two regular expressions diverge. The possessive dot-star wants it all. No backtracking 
is done. Since the «
"
» failed, there are no permutations left to try, and the overall match attempt fails. The 
greedy dot-star, while initially grabbing everything, is willing to give back. It will backtrack one character at a 
time. Backtracking to „
abc"
µ, «
"
» fails to match ´
x
µ. Backtracking to „
abc
µ, «
"
» matches „
"
µ. An overall 
match „
"abc"
µ was found. 
Essentially, the lesson here is that when using possessive quantifiers, you need to make sure that whatever 
you’re applying the possessive quantifier to should not be able to match what should follow it. The problem 
in the above example is that the dot also matches the closing quote. This prevents us from using a possessive 
quantifier. The negated character class in the previous section cannot match the closing quote, so we can 
make it possessive. 
Using Atomic Grouping Instead of Possessive Quantifiers 
Technically, possessive quantifiers are a notational convenience to place an atomic group around a single 
quantifier. All regex flavors that support possessive quantifiers also support atomic grouping. But not all 
regex flavors that support atomic grouping support possessive quantifiers. With those flavors, you can 
achieve the exact same results using an atomic group. 
Basically, instead of «
X*+
», write «
(?>X*)
». It is important to notice that both the quantified token X and the 
quantifier are inside the atomic group. Even if X is a group, you still need to put an extra atomic group 
around it to achieve the same effect. «
(?:a|b)*+
» is equivalent to «
(?>(?:a|b)*)
» but not to «
(?>a|b)*
». 
.NET PDF SDK - Description of All PDF Processing Control Feastures
Create signatures in existing PDF signature fields; Create signatures in new fields which hold the signature; Add signature image to PDF file. PDF Hyperlink Edit
add a jpeg to a pdf; add image to pdf online
How to C#: Basic SDK Concept of XDoc.PDF for .NET
In general, image extraction, editing, drawing, and You may add PDF document protection functionality into your C# PDF password and digital signature, and set
how to add a picture to a pdf file; acrobat insert image in pdf
301 
The latter is a valid regular expression, but it won’t have the same effect when used as part of a larger regular 
expression. 
E.g. «
(?:a|b)*+b
» and «
(?>(?:a|b)*)b
» both fail to match ´
b
µ. «
a|b
» will match the „
b
µ. The star is 
satisfied, and the fact that it’s possessive or the atomic group will cause the star to forget all its backtracking 
positions. The second «
b
» in the regex has nothing left to match, and the overall match attempt fails. 
In the regex «
(?>a|b)*b
», the atomic group forces the alternation to give up its backtracking positions. I.e. if 
an „
a
µ is matched, it won’t come back to try «
b
» if the rest of the regex fails. Since the star is outside of the 
group, it is a normal, greedy star. When the second «
b
» fails, the greedy star will backtrack to zero iterations. 
Then, the second «
b
» matches the „
b
µ in the subject string. 
This distinction is particularly important when converting a regular expression written by somebody else 
using possessive quantifiers to a regex flavor that doesn’t have possessive quantifiers. You could, of course, 
let a tool like RegexBuddy do the job for you. 
302 
17. Atomic Grouping 
An  atomic  group  is  a group that,  when  the regex engine exits from it, automatically throws away all 
backtracking positions remembered by any tokens inside the group. Atomic groups are non-capturing. The 
syntax is «
(?>group)
». Lookaround groups are also atomic. Atomic grouping is supported by most modern 
regular expression flavors, including the JGsoft flavor, Java, PCRE, .NET, Perl and Ruby. The first three of 
these also support possessive quantifiers, which are essentially a notational convenience for atomic grouping. 
An example will make the behavior of atomic groups clear. The regular expression «
a(bc|b)c
» (capturing 
group) matches „
abcc
µ and „
abc
µ. The regex «
a(?>bc|b)c
» (atomic group) matches „
abcc
µ but not 
´
abc
µ. 
When applied to ´
abc
µ, both regexes will match «
a
» to „
a
µ, «
bc
» to „
bc
µ, and then «
c
» will fail to match at 
the end of the string. Here their paths diverge. The regex with the capturing group has remembered a 
backtracking position for the alternation. The group will give up its match, «
b
» then matches „
b
µ and «
c
» 
matches „
c
µ. Match found! 
The regex with the atomic group, however, exited from an atomic group after «
bc
» was matched. At that 
point, all backtracking positions for tokens inside the group are discarded. In this example, the alternation’s 
option to try «
b
» at the second position in the string is discarded. As a result, when «
c
» fails, the regex engine 
has no alternatives left to try. 
Of course, the above example isn’t very useful. But it does illustrate very clearly how atomic grouping 
eliminates certain matches. Or more importantly, it eliminates certain match attempts. 
Regex Optimization Using Atomic Grouping 
Consider the regex «
\b(integer|insert|in)\b
» and the subject ´
integers
µ. Obviously, because of the 
word boundaries, these don’t match. What’s not so obvious is that the regex engine will spend quite some 
effort figuring this out. 
«
\b
» matches at the start of the string, and «
integer
» matches „
integer
µ. The regex engine makes note 
that there are two more alternatives in the group, and continues with «
\b
». This fails to match between the 
´
r
µ and ´
s
µ. So the engine backtracks to try the second alternative inside the group. The second alternative 
matches „
in
µ, but then fails to match «
s
». So the engine backtracks once more to the third alternative. «
in
» 
matches „
in
µ. «
\b
» fails between the ´
n
µ and ´
t
µ this time. The regex engine has no more remembered 
backtracking positions, so it declares failure. 
This is quite a lot of work to figure out ´
integers
µ isn’t in our list of words. We can optimize this by telling 
the regular expression engine that if it can’t match «
\b
» after it matched „
integer
µ, then it shouldn’t bother 
trying any of the other words. The word we’ve encountered in the subject string is a longer word, and it isn’t 
in our list. 
We can do this by turning the capturing group into an atomic group: «
\b(?>integer|insert|in)\b
». 
Now, when «
integer
» matches, the engine exits from an atomic group, and throws away the backtracking 
positions it stored for the alternation. When «
\b
» fails, the engine gives up immediately. This savings can be 
significant when scanning a large file for a long list of keywords. This savings will be vital when your 
alternatives contain repeated tokens (not to mention repeated groups) that lead to catastrophic backtracking. 
303 
Don’t be too quick to make all your groups atomic. As we saw in the first example above, atomic grouping 
can  exclude  valid  matches  too.  Compare  how  «
\b(?>integer|insert|in)\b
»  and 
«
\b(?>in|integer|insert)\b
» behave when applied to ´
insert
µ. The former regex matches, while the 
latter fails. If the groups weren’t atomic, both regexes would match. Remember that alternation tries its 
alternatives from left to right. If the second regex matches „
in
µ, it won’t try the two other alternatives due to 
the atomic group. 
304 
18. Lookahead and Lookbehind Zero-Width Assertions 
Perl 5 introduced two very powerful constructs: ´lookaheadµ and ´lookbehindµ. Collectively, these are called 
´lookaroundµ. They are also called ´zero-width assertionsµ. They are zero-width just like the start and end of 
line, and start and end of word anchors that I already explained. The difference is that lookarounds will 
actually match characters, but then give up the match and only return the result: match or no match. That is 
why they are called ´assertionsµ. They do not consume characters in the string, but only assert whether a 
match is possible or not. Lookarounds allow you to create regular expressions that are impossible to create 
without them, or that would get very longwinded without them. 
Positive and Negative Lookahead 
Negative lookahead is indispensable if you want to match something not followed by something else. When 
explaining character classes, I already explained why you cannot use a negated character class to match a ´qµ 
not  followed by  a ´uµ. Negative  lookahead provides  the  solution:  «
q(?!u)
».  The  negative  lookahead 
construct is the pair of round brackets, with the opening bracket followed by a question mark and an 
exclamation point. Inside the lookahead, we have the trivial regex «
u
». 
Positive lookahead works just the same. «
q(?=u)
» matches a q that is followed by a u, without making the u 
part of the match. The positive lookahead construct is a pair of round brackets, with the opening bracket 
followed by a question mark and an equals sign. 
You can use any regular expression inside the lookahead. (Note that this is not the case with lookbehind. I 
will explain why below.) Any valid regular expression can be used inside the lookahead. If it contains 
capturing parentheses, the backreferences will be saved. Note that the lookahead itself does not create a 
backreference. So it is not included in the count towards numbering the backreferences. If you want to store 
the match of the regex inside a backreference, you have to put capturing parentheses around the regex inside 
the lookahead, like this: «
(?=(regex))
». The other way around will not work, because the lookahead will 
already have discarded the regex match by the time the backreference is to be saved. 
Regex Engine Internals 
First, let’s see how the engine applies «
q(?!u)
» to the string ´
Iraq
µ. The first token in the regex is the literal 
«
q
». As we already know, this will cause the engine to traverse the string until the „
q
µ in the string is matched. 
The position in the string is now the void behind the string. The next token is the lookahead. The engine 
takes note that it is inside a lookahead construct now, and begins matching the regex inside the lookahead. So 
the next token is «
u
». This does not match the void behind the string. The engine notes that the regex inside 
the lookahead failed. Because the lookahead is negative, this means that the lookahead has successfully 
matched at the current position. At this point, the entire regex has matched, and „
q
µ is returned as the match. 
Let’s try applying the same regex to ´
quit
µ. «
q
» matches „
q
µ. The next token is the «
u
» inside the lookahead. 
The next character is the ´
u
µ. These match. The engine advances to the next character: ´
i
µ. However, it is 
done with the regex inside the lookahead. The engine notes success, and discards the regex match. This 
causes the engine to step back in the string to ´
u
µ. 
305 
Because the lookahead is negative, the successful match inside it causes the lookahead to fail. Since there are 
no other permutations of this regex, the engine has to start again at the beginning. Since «
q
» cannot match 
anywhere else, the engine reports failure. 
Let’s take one more look inside, to make sure you understand the implications of the lookahead. Let’s apply 
«
q(?=u)i
» to ´
quit
µ. I have made the lookahead positive, and put a token after it. Again, «
q
» matches „
q
µ 
and «
u
» matches „
u
µ. Again, the match from the lookahead must be discarded, so the engine steps back from 
´
i
µ in the string to ´
u
µ. The lookahead was successful, so the engine continues with «
i
». But «
i
» cannot 
match ´
u
µ. So this match attempt fails. All remaining attempts will fail as well, because there are no more q’s 
in the string. 
Positive and Negative Lookbehind 
Lookbehind has the same effect, but works backwards. It tells the regex engine to temporarily step backwards 
in the string, to check if the text inside the lookbehind can be matched there. «
(?<!a)b
» matches a ´bµ that 
is not preceded by an ´aµ, using negative lookbehind. It will not match ´
cab
µ, but will match the „
b
µ (and 
only the „
b
µ) in ´
bed
µ or ´
debt
µ. «
(?<=a)b
» (positive lookbehind) matches the „
b
µ (and only the „
b
µ) in 
cab
µ, but does not match ´
bed
µ or ´
debt
µ. 
The construct for positive lookbehind is «
(?<=text)
»: a pair of round brackets, with the opening bracket 
followed by a question mark, ´less thanµ symbol and an equals sign. Negative lookbehind is written as 
«
(?<!text)
», using an exclamation point instead of an equals sign. 
More Regex Engine Internals 
Let’s apply «
(?<=a)b
» to ´
thingamabob
µ. The engine starts with the lookbehind and the first character in 
the string. In this case, the lookbehind tells the engine to step back one character, and see if an ´aµ can be 
matched there. The engine cannot step back one character because there are no characters before the ´
t
µ. So 
the lookbehind fails, and the engine starts again at  the next  character, the ´
h
µ. (Note that a negative 
lookbehind would have succeeded here.) Again, the engine temporarily steps back one character to check if 
an ´aµ can be found there. It finds a ´
t
µ, so the positive lookbehind fails again. 
The lookbehind continues to fail until the regex reaches the ´
m
µ in the string. The engine again steps back 
one character, and notices that the „
a
µ can be matched there. The positive lookbehind matches. Because it is 
zero-width, the current position in the string remains at the ´
m
µ. The next token is «
b
», which cannot match 
here. The next character is the second ´
a
µ in the string. The engine steps back, and finds out that the ´
m
µ 
does not match «
a
». 
The next character is the first ´
b
µ in the string. The engine steps back and finds out that „
a
µ satisfies the 
lookbehind. «
b
» matches „
b
µ, and the entire regex has been matched successfully. It matches one character: 
the first „
b
µ in the string. 
Important Notes About Lookbehind 
The good news is that you can use lookbehind anywhere in the regex, not only at the start. If you want to find 
a word not  ending with  an ´sµ, you could use  «
\b\w+(?<!s)\b
». This  is  definitely not  the  same  as 
Documents you may be interested
Documents you may be interested