code: def originalTextFor(expr, asString=True):
      
      locMarker = Empty().setParseAction(lambda s,loc,t: loc)
      endlocMarker = locMarker.copy()
      endlocMarker.callPreparse = False
      matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
      if asString:
          extractText = lambda s,l,t: s[t._original_start:t._original_end]
      else:
          def extractText(s,l,t):
              t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]
      matchExpr.setParseAction(extractText)
      matchExpr.ignoreExprs = expr.ignoreExprs
      return matchExpr
docs: Helper to return the original, untokenized text for a given
      expression.  Useful to restore the parsed fields of an HTML start
      tag into the raw tag text itself, or to revert separate tokens with
      intervening whitespace back to the original matching input text. By
      default, returns astring containing the original parsed text.
  
      If the optional ``asString`` argument is passed as
      ``False``, then the return value is
      a :class:`ParseResults` containing any results names that
      were originally matched, and a single token containing the original
      matched text from the input string.  So if the expression passed to
      :class:`originalTextFor` contains expressions with defined
      results names, you must set ``asString`` to ``False`` if you
      want to preserve those results name values.
  
      Example::
  
          src = "this is test <b> bold <i>text</i> </b> normal text "
          for tag in ("b","i"):
              opener,closer = makeHTMLTags(tag)
              patt = originalTextFor(opener + SkipTo(closer) + closer)
              print(patt.searchString(src)[0])
  
      prints::
  
          ['<b> bold <i>text</i> </b>']
          ['<i>text</i>']