Add option to control if the output is HTMLEscaped

evanphx · evanphx · commit 9d7ba23eb0b5 · 2024-01-27T15:25:25.000-08:00
diff --git a/v5/internal/json/encode.go b/v5/internal/json/encode.go
@@ -167,6 +167,19 @@ func Marshal(v any) ([]byte, error) {
 	return buf, nil
 }
 
+func MarshalEscaped(v any, escape bool) ([]byte, error) {
+	e := newEncodeState()
+	defer encodeStatePool.Put(e)
+
+	err := e.marshal(v, encOpts{escapeHTML: escape})
+	if err != nil {
+		return nil, err
+	}
+	buf := append([]byte(nil), e.Bytes()...)
+
+	return buf, nil
+}
+
 // MarshalIndent is like Marshal but applies Indent to format the output.
 // Each JSON element in the output will begin on a new line beginning with prefix
 // followed by one or more copies of indent according to the indentation nesting.
diff --git a/v5/merge.go b/v5/merge.go
@@ -10,26 +10,26 @@ import (
 	"github.com/evanphx/json-patch/v5/internal/json"
 )
 
-func merge(cur, patch *lazyNode, mergeMerge bool) *lazyNode {
-	curDoc, err := cur.intoDoc()
+func merge(cur, patch *lazyNode, mergeMerge bool, options *ApplyOptions) *lazyNode {
+	curDoc, err := cur.intoDoc(options)
 
 	if err != nil {
-		pruneNulls(patch)
+		pruneNulls(patch, options)
 		return patch
 	}
 
-	patchDoc, err := patch.intoDoc()
+	patchDoc, err := patch.intoDoc(options)
 
 	if err != nil {
 		return patch
 	}
 
-	mergeDocs(curDoc, patchDoc, mergeMerge)
+	mergeDocs(curDoc, patchDoc, mergeMerge, options)
 
 	return cur
 }
 
-func mergeDocs(doc, patch *partialDoc, mergeMerge bool) {
+func mergeDocs(doc, patch *partialDoc, mergeMerge bool, options *ApplyOptions) {
 	for k, v := range patch.obj {
 		if v == nil {
 			if mergeMerge {
@@ -45,55 +45,55 @@ func mergeDocs(doc, patch *partialDoc, mergeMerge bool) {
 				}
 				doc.obj[k] = nil
 			} else {
-				_ = doc.remove(k, &ApplyOptions{})
+				_ = doc.remove(k, options)
 			}
 		} else {
 			cur, ok := doc.obj[k]
 
 			if !ok || cur == nil {
 				if !mergeMerge {
-					pruneNulls(v)
+					pruneNulls(v, options)
 				}
-				_ = doc.set(k, v, &ApplyOptions{})
+				_ = doc.set(k, v, options)
 			} else {
-				_ = doc.set(k, merge(cur, v, mergeMerge), &ApplyOptions{})
+				_ = doc.set(k, merge(cur, v, mergeMerge, options), options)
 			}
 		}
 	}
 }
 
-func pruneNulls(n *lazyNode) {
-	sub, err := n.intoDoc()
+func pruneNulls(n *lazyNode, options *ApplyOptions) {
+	sub, err := n.intoDoc(options)
 
 	if err == nil {
-		pruneDocNulls(sub)
+		pruneDocNulls(sub, options)
 	} else {
 		ary, err := n.intoAry()
 
 		if err == nil {
-			pruneAryNulls(ary)
+			pruneAryNulls(ary, options)
 		}
 	}
 }
 
-func pruneDocNulls(doc *partialDoc) *partialDoc {
+func pruneDocNulls(doc *partialDoc, options *ApplyOptions) *partialDoc {
 	for k, v := range doc.obj {
 		if v == nil {
 			_ = doc.remove(k, &ApplyOptions{})
 		} else {
-			pruneNulls(v)
+			pruneNulls(v, options)
 		}
 	}
 
 	return doc
 }
 
-func pruneAryNulls(ary *partialArray) *partialArray {
+func pruneAryNulls(ary *partialArray, options *ApplyOptions) *partialArray {
 	newAry := []*lazyNode{}
 
 	for _, v := range ary.nodes {
 		if v != nil {
-			pruneNulls(v)
+			pruneNulls(v, options)
 		}
 		newAry = append(newAry, v)
 	}
@@ -128,11 +128,17 @@ func doMergePatch(docData, patchData []byte, mergeMerge bool) ([]byte, error) {
 		return nil, errBadJSONPatch
 	}
 
-	doc := &partialDoc{}
+	options := NewApplyOptions()
+
+	doc := &partialDoc{
+		opts: options,
+	}
 
 	docErr := doc.UnmarshalJSON(docData)
 
-	patch := &partialDoc{}
+	patch := &partialDoc{
+		opts: options,
+	}
 
 	patchErr := patch.UnmarshalJSON(patchData)
 
@@ -158,7 +164,7 @@ func doMergePatch(docData, patchData []byte, mergeMerge bool) ([]byte, error) {
 			if mergeMerge {
 				doc = patch
 			} else {
-				doc = pruneDocNulls(patch)
+				doc = pruneDocNulls(patch, options)
 			}
 		} else {
 			patchAry := &partialArray{}
@@ -172,7 +178,7 @@ func doMergePatch(docData, patchData []byte, mergeMerge bool) ([]byte, error) {
 				return nil, errBadJSONPatch
 			}
 
-			pruneAryNulls(patchAry)
+			pruneAryNulls(patchAry, options)
 
 			out, patchErr := json.Marshal(patchAry.nodes)
 
@@ -183,7 +189,7 @@ func doMergePatch(docData, patchData []byte, mergeMerge bool) ([]byte, error) {
 			return out, nil
 		}
 	} else {
-		mergeDocs(doc, patch, mergeMerge)
+		mergeDocs(doc, patch, mergeMerge, options)
 	}
 
 	return json.Marshal(doc)
diff --git a/v5/patch.go b/v5/patch.go
@@ -60,6 +60,8 @@ type partialDoc struct {
 	self *lazyNode
 	keys []string
 	obj  map[string]*lazyNode
+
+	opts *ApplyOptions
 }
 
 type partialArray struct {
@@ -90,6 +92,8 @@ type ApplyOptions struct {
 	// EnsurePathExistsOnAdd instructs json-patch to recursively create the missing parts of path on "add" operation.
 	// Default to false.
 	EnsurePathExistsOnAdd bool
+
+	EscapeHTML bool
 }
 
 // NewApplyOptions creates a default set of options for calls to ApplyWithOptions.
@@ -99,6 +103,7 @@ func NewApplyOptions() *ApplyOptions {
 		AccumulatedCopySizeLimit: AccumulatedCopySizeLimit,
 		AllowMissingPathOnRemove: false,
 		EnsurePathExistsOnAdd:    false,
+		EscapeHTML:               true,
 	}
 }
 
@@ -143,7 +148,7 @@ func (n *partialDoc) TrustMarshalJSON(buf *bytes.Buffer) error {
 				return err
 			}
 		}
-		key, err := json.Marshal(k)
+		key, err := json.MarshalEscaped(k, n.opts.EscapeHTML)
 		if err != nil {
 			return err
 		}
@@ -153,7 +158,7 @@ func (n *partialDoc) TrustMarshalJSON(buf *bytes.Buffer) error {
 		if err := buf.WriteByte(':'); err != nil {
 			return err
 		}
-		value, err := json.Marshal(n.obj[k])
+		value, err := json.MarshalEscaped(n.obj[k], n.opts.EscapeHTML)
 		if err != nil {
 			return err
 		}
@@ -194,11 +199,11 @@ func (n *partialArray) RedirectMarshalJSON() (interface{}, error) {
 	return n.nodes, nil
 }
 
-func deepCopy(src *lazyNode) (*lazyNode, int, error) {
+func deepCopy(src *lazyNode, options *ApplyOptions) (*lazyNode, int, error) {
 	if src == nil {
 		return nil, 0, nil
 	}
-	a, err := json.Marshal(src)
+	a, err := json.MarshalEscaped(src, options.EscapeHTML)
 	if err != nil {
 		return nil, 0, err
 	}
@@ -216,7 +221,7 @@ func (n *lazyNode) nextByte() byte {
 	return s[0]
 }
 
-func (n *lazyNode) intoDoc() (*partialDoc, error) {
+func (n *lazyNode) intoDoc(options *ApplyOptions) (*partialDoc, error) {
 	if n.which == eDoc {
 		return n.doc, nil
 	}
@@ -235,6 +240,7 @@ func (n *lazyNode) intoDoc() (*partialDoc, error) {
 		return nil, ErrInvalid
 	}
 
+	n.doc.opts = options
 	if err != nil {
 		return nil, err
 	}
@@ -545,7 +551,7 @@ func findObject(pd *container, path string, options *ApplyOptions) (container, s
 				return nil, ""
 			}
 		} else {
-			doc, err = next.intoDoc()
+			doc, err = next.intoDoc(options)
 
 			if err != nil {
 				return nil, ""
@@ -750,6 +756,7 @@ func (p Patch) add(doc *container, op Operation, options *ApplyOptions) error {
 		} else {
 			pd = &partialDoc{
 				self: val,
+				opts: options,
 			}
 		}
 
@@ -855,7 +862,7 @@ func ensurePathExists(pd *container, path string, options *ApplyOptions) error {
 				newNode := newLazyNode(newRawMessage(rawJSONObject))
 
 				doc.add(part, newNode, options)
-				doc, err = newNode.intoDoc()
+				doc, err = newNode.intoDoc(options)
 				if err != nil {
 					return err
 				}
@@ -868,7 +875,7 @@ func ensurePathExists(pd *container, path string, options *ApplyOptions) error {
 					return err
 				}
 			} else {
-				doc, err = target.intoDoc()
+				doc, err = target.intoDoc(options)
 
 				if err != nil {
 					return err
@@ -954,6 +961,8 @@ func (p Patch) replace(doc *container, op Operation, options *ApplyOptions) erro
 				if !val.tryAry() {
 					return errors.Wrapf(err, "replace operation value must be object or array")
 				}
+			} else {
+				val.doc.opts = options
 			}
 		}
 
@@ -1115,7 +1124,7 @@ func (p Patch) copy(doc *container, op Operation, accumulatedCopySize *int64, op
 		return errors.Wrapf(ErrMissing, "copy operation does not apply: doc is missing destination path: %s", path)
 	}
 
-	valCopy, sz, err := deepCopy(val)
+	valCopy, sz, err := deepCopy(val, options)
 	if err != nil {
 		return errors.Wrapf(err, "error while performing deep copy")
 	}
@@ -1202,6 +1211,7 @@ func (p Patch) ApplyIndentWithOptions(doc []byte, indent string, options *ApplyO
 	} else {
 		pd = &partialDoc{
 			self: self,
+			opts: options,
 		}
 	}
 
@@ -1238,11 +1248,18 @@ func (p Patch) ApplyIndentWithOptions(doc []byte, indent string, options *ApplyO
 		}
 	}
 
-	if indent != "" {
-		return json.MarshalIndent(pd, "", indent)
+	data, err := json.MarshalEscaped(pd, options.EscapeHTML)
+	if err != nil {
+		return nil, err
+	}
+
+	if indent == "" {
+		return data, nil
 	}
 
-	return json.Marshal(pd)
+	var buf bytes.Buffer
+	json.Indent(&buf, data, "", indent)
+	return buf.Bytes(), nil
 }
 
 // From http://tools.ietf.org/html/rfc6901#section-4 :

Original file line number	Diff line number	Diff line change
`@@ -10,26 +10,26 @@ import (`
`10`	`10`	`"github.com/evanphx/json-patch/v5/internal/json"`
`11`	`11`	`)`
`12`	`12`
`13`		`-func merge(cur, patch lazyNode, mergeMerge bool) lazyNode {`
`14`		`- curDoc, err := cur.intoDoc()`
	`13`	`+func merge(cur, patch lazyNode, mergeMerge bool, options ApplyOptions) *lazyNode {`
	`14`	`+ curDoc, err := cur.intoDoc(options)`
`15`	`15`
`16`	`16`	`if err != nil {`
`17`		`- pruneNulls(patch)`
	`17`	`+ pruneNulls(patch, options)`
`18`	`18`	`return patch`
`19`	`19`	`}`
`20`	`20`
`21`		`- patchDoc, err := patch.intoDoc()`
	`21`	`+ patchDoc, err := patch.intoDoc(options)`
`22`	`22`
`23`	`23`	`if err != nil {`
`24`	`24`	`return patch`
`25`	`25`	`}`
`26`	`26`
`27`		`- mergeDocs(curDoc, patchDoc, mergeMerge)`
	`27`	`+ mergeDocs(curDoc, patchDoc, mergeMerge, options)`
`28`	`28`
`29`	`29`	`return cur`
`30`	`30`	`}`
`31`	`31`
`32`		`-func mergeDocs(doc, patch *partialDoc, mergeMerge bool) {`
	`32`	`+func mergeDocs(doc, patch partialDoc, mergeMerge bool, options ApplyOptions) {`
`33`	`33`	`for k, v := range patch.obj {`
`34`	`34`	`if v == nil {`
`35`	`35`	`if mergeMerge {`
`@@ -45,55 +45,55 @@ func mergeDocs(doc, patch *partialDoc, mergeMerge bool) {`
`45`	`45`	`}`
`46`	`46`	`doc.obj[k] = nil`
`47`	`47`	`} else {`
`48`		`- _ = doc.remove(k, &ApplyOptions{})`
	`48`	`+ _ = doc.remove(k, options)`
`49`	`49`	`}`
`50`	`50`	`} else {`
`51`	`51`	`cur, ok := doc.obj[k]`
`52`	`52`
`53`	`53`	`if !ok \|\| cur == nil {`
`54`	`54`	`if !mergeMerge {`
`55`		`- pruneNulls(v)`
	`55`	`+ pruneNulls(v, options)`
`56`	`56`	`}`
`57`		`- _ = doc.set(k, v, &ApplyOptions{})`
	`57`	`+ _ = doc.set(k, v, options)`
`58`	`58`	`} else {`
`59`		`- _ = doc.set(k, merge(cur, v, mergeMerge), &ApplyOptions{})`
	`59`	`+ _ = doc.set(k, merge(cur, v, mergeMerge, options), options)`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`65`		`-func pruneNulls(n *lazyNode) {`
`66`		`- sub, err := n.intoDoc()`
	`65`	`+func pruneNulls(n lazyNode, options ApplyOptions) {`
	`66`	`+ sub, err := n.intoDoc(options)`
`67`	`67`
`68`	`68`	`if err == nil {`
`69`		`- pruneDocNulls(sub)`
	`69`	`+ pruneDocNulls(sub, options)`
`70`	`70`	`} else {`
`71`	`71`	`ary, err := n.intoAry()`
`72`	`72`
`73`	`73`	`if err == nil {`
`74`		`- pruneAryNulls(ary)`
	`74`	`+ pruneAryNulls(ary, options)`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`		`-func pruneDocNulls(doc partialDoc) partialDoc {`
	`79`	`+func pruneDocNulls(doc partialDoc, options ApplyOptions) *partialDoc {`
`80`	`80`	`for k, v := range doc.obj {`
`81`	`81`	`if v == nil {`
`82`	`82`	`_ = doc.remove(k, &ApplyOptions{})`
`83`	`83`	`} else {`
`84`		`- pruneNulls(v)`
	`84`	`+ pruneNulls(v, options)`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`return doc`
`89`	`89`	`}`
`90`	`90`
`91`		`-func pruneAryNulls(ary partialArray) partialArray {`
	`91`	`+func pruneAryNulls(ary partialArray, options ApplyOptions) *partialArray {`
`92`	`92`	`newAry := []*lazyNode{}`
`93`	`93`
`94`	`94`	`for _, v := range ary.nodes {`
`95`	`95`	`if v != nil {`
`96`		`- pruneNulls(v)`
	`96`	`+ pruneNulls(v, options)`
`97`	`97`	`}`
`98`	`98`	`newAry = append(newAry, v)`
`99`	`99`	`}`
`@@ -128,11 +128,17 @@ func doMergePatch(docData, patchData []byte, mergeMerge bool) ([]byte, error) {`
`128`	`128`	`return nil, errBadJSONPatch`
`129`	`129`	`}`
`130`	`130`
`131`		`- doc := &partialDoc{}`
	`131`	`+ options := NewApplyOptions()`
	`132`	`+`
	`133`	`+ doc := &partialDoc{`
	`134`	`+ opts: options,`
	`135`	`+ }`
`132`	`136`
`133`	`137`	`docErr := doc.UnmarshalJSON(docData)`
`134`	`138`
`135`		`- patch := &partialDoc{}`
	`139`	`+ patch := &partialDoc{`
	`140`	`+ opts: options,`
	`141`	`+ }`
`136`	`142`
`137`	`143`	`patchErr := patch.UnmarshalJSON(patchData)`
`138`	`144`
`@@ -158,7 +164,7 @@ func doMergePatch(docData, patchData []byte, mergeMerge bool) ([]byte, error) {`
`158`	`164`	`if mergeMerge {`
`159`	`165`	`doc = patch`
`160`	`166`	`} else {`
`161`		`- doc = pruneDocNulls(patch)`
	`167`	`+ doc = pruneDocNulls(patch, options)`
`162`	`168`	`}`
`163`	`169`	`} else {`
`164`	`170`	`patchAry := &partialArray{}`
`@@ -172,7 +178,7 @@ func doMergePatch(docData, patchData []byte, mergeMerge bool) ([]byte, error) {`
`172`	`178`	`return nil, errBadJSONPatch`
`173`	`179`	`}`
`174`	`180`
`175`		`- pruneAryNulls(patchAry)`
	`181`	`+ pruneAryNulls(patchAry, options)`
`176`	`182`
`177`	`183`	`out, patchErr := json.Marshal(patchAry.nodes)`
`178`	`184`
`@@ -183,7 +189,7 @@ func doMergePatch(docData, patchData []byte, mergeMerge bool) ([]byte, error) {`
`183`	`189`	`return out, nil`
`184`	`190`	`}`
`185`	`191`	`} else {`
`186`		`- mergeDocs(doc, patch, mergeMerge)`
	`192`	`+ mergeDocs(doc, patch, mergeMerge, options)`
`187`	`193`	`}`
`188`	`194`
`189`	`195`	`return json.Marshal(doc)`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,8 @@ type partialDoc struct {`
`60`	`60`	`self *lazyNode`
`61`	`61`	`keys []string`
`62`	`62`	`obj map[string]*lazyNode`
	`63`	`+`
	`64`	`+ opts *ApplyOptions`
`63`	`65`	`}`
`64`	`66`
`65`	`67`	`type partialArray struct {`
`@@ -90,6 +92,8 @@ type ApplyOptions struct {`
`90`	`92`	`// EnsurePathExistsOnAdd instructs json-patch to recursively create the missing parts of path on "add" operation.`
`91`	`93`	`// Default to false.`
`92`	`94`	`EnsurePathExistsOnAdd bool`
	`95`	`+`
	`96`	`+ EscapeHTML bool`
`93`	`97`	`}`
`94`	`98`
`95`	`99`	`// NewApplyOptions creates a default set of options for calls to ApplyWithOptions.`
`@@ -99,6 +103,7 @@ func NewApplyOptions() *ApplyOptions {`
`99`	`103`	`AccumulatedCopySizeLimit: AccumulatedCopySizeLimit,`
`100`	`104`	`AllowMissingPathOnRemove: false,`
`101`	`105`	`EnsurePathExistsOnAdd: false,`
	`106`	`+ EscapeHTML: true,`
`102`	`107`	`}`
`103`	`108`	`}`
`104`	`109`
`@@ -143,7 +148,7 @@ func (n partialDoc) TrustMarshalJSON(buf bytes.Buffer) error {`
`143`	`148`	`return err`
`144`	`149`	`}`
`145`	`150`	`}`
`146`		`- key, err := json.Marshal(k)`
	`151`	`+ key, err := json.MarshalEscaped(k, n.opts.EscapeHTML)`
`147`	`152`	`if err != nil {`
`148`	`153`	`return err`
`149`	`154`	`}`
`@@ -153,7 +158,7 @@ func (n partialDoc) TrustMarshalJSON(buf bytes.Buffer) error {`
`153`	`158`	`if err := buf.WriteByte(':'); err != nil {`
`154`	`159`	`return err`
`155`	`160`	`}`
`156`		`- value, err := json.Marshal(n.obj[k])`
	`161`	`+ value, err := json.MarshalEscaped(n.obj[k], n.opts.EscapeHTML)`
`157`	`162`	`if err != nil {`
`158`	`163`	`return err`
`159`	`164`	`}`
`@@ -194,11 +199,11 @@ func (n *partialArray) RedirectMarshalJSON() (interface{}, error) {`
`194`	`199`	`return n.nodes, nil`
`195`	`200`	`}`
`196`	`201`
`197`		`-func deepCopy(src lazyNode) (lazyNode, int, error) {`
	`202`	`+func deepCopy(src lazyNode, options ApplyOptions) (*lazyNode, int, error) {`
`198`	`203`	`if src == nil {`
`199`	`204`	`return nil, 0, nil`
`200`	`205`	`}`
`201`		`- a, err := json.Marshal(src)`
	`206`	`+ a, err := json.MarshalEscaped(src, options.EscapeHTML)`
`202`	`207`	`if err != nil {`
`203`	`208`	`return nil, 0, err`
`204`	`209`	`}`
`@@ -216,7 +221,7 @@ func (n *lazyNode) nextByte() byte {`
`216`	`221`	`return s[0]`
`217`	`222`	`}`
`218`	`223`
`219`		`-func (n lazyNode) intoDoc() (partialDoc, error) {`
	`224`	`+func (n lazyNode) intoDoc(options ApplyOptions) (*partialDoc, error) {`
`220`	`225`	`if n.which == eDoc {`
`221`	`226`	`return n.doc, nil`
`222`	`227`	`}`
`@@ -235,6 +240,7 @@ func (n lazyNode) intoDoc() (partialDoc, error) {`
`235`	`240`	`return nil, ErrInvalid`
`236`	`241`	`}`
`237`	`242`
	`243`	`+ n.doc.opts = options`
`238`	`244`	`if err != nil {`
`239`	`245`	`return nil, err`
`240`	`246`	`}`
`@@ -545,7 +551,7 @@ func findObject(pd container, path string, options ApplyOptions) (container, s`
`545`	`551`	`return nil, ""`
`546`	`552`	`}`
`547`	`553`	`} else {`
`548`		`- doc, err = next.intoDoc()`
	`554`	`+ doc, err = next.intoDoc(options)`
`549`	`555`
`550`	`556`	`if err != nil {`
`551`	`557`	`return nil, ""`
`@@ -750,6 +756,7 @@ func (p Patch) add(doc container, op Operation, options ApplyOptions) error {`
`750`	`756`	`} else {`
`751`	`757`	`pd = &partialDoc{`
`752`	`758`	`self: val,`
	`759`	`+ opts: options,`
`753`	`760`	`}`
`754`	`761`	`}`
`755`	`762`
`@@ -855,7 +862,7 @@ func ensurePathExists(pd container, path string, options ApplyOptions) error {`
`855`	`862`	`newNode := newLazyNode(newRawMessage(rawJSONObject))`
`856`	`863`
`857`	`864`	`doc.add(part, newNode, options)`
`858`		`- doc, err = newNode.intoDoc()`
	`865`	`+ doc, err = newNode.intoDoc(options)`
`859`	`866`	`if err != nil {`
`860`	`867`	`return err`
`861`	`868`	`}`
`@@ -868,7 +875,7 @@ func ensurePathExists(pd container, path string, options ApplyOptions) error {`
`868`	`875`	`return err`
`869`	`876`	`}`
`870`	`877`	`} else {`
`871`		`- doc, err = target.intoDoc()`
	`878`	`+ doc, err = target.intoDoc(options)`
`872`	`879`
`873`	`880`	`if err != nil {`
`874`	`881`	`return err`
`@@ -954,6 +961,8 @@ func (p Patch) replace(doc container, op Operation, options ApplyOptions) erro`
`954`	`961`	`if !val.tryAry() {`
`955`	`962`	`return errors.Wrapf(err, "replace operation value must be object or array")`
`956`	`963`	`}`
	`964`	`+ } else {`
	`965`	`+ val.doc.opts = options`
`957`	`966`	`}`
`958`	`967`	`}`
`959`	`968`
`@@ -1115,7 +1124,7 @@ func (p Patch) copy(doc container, op Operation, accumulatedCopySize int64, op`
`1115`	`1124`	`return errors.Wrapf(ErrMissing, "copy operation does not apply: doc is missing destination path: %s", path)`
`1116`	`1125`	`}`
`1117`	`1126`
`1118`		`- valCopy, sz, err := deepCopy(val)`
	`1127`	`+ valCopy, sz, err := deepCopy(val, options)`
`1119`	`1128`	`if err != nil {`
`1120`	`1129`	`return errors.Wrapf(err, "error while performing deep copy")`
`1121`	`1130`	`}`
`@@ -1202,6 +1211,7 @@ func (p Patch) ApplyIndentWithOptions(doc []byte, indent string, options *ApplyO`
`1202`	`1211`	`} else {`
`1203`	`1212`	`pd = &partialDoc{`
`1204`	`1213`	`self: self,`
	`1214`	`+ opts: options,`
`1205`	`1215`	`}`
`1206`	`1216`	`}`
`1207`	`1217`
`@@ -1238,11 +1248,18 @@ func (p Patch) ApplyIndentWithOptions(doc []byte, indent string, options *ApplyO`
`1238`	`1248`	`}`
`1239`	`1249`	`}`
`1240`	`1250`
`1241`		`- if indent != "" {`
`1242`		`- return json.MarshalIndent(pd, "", indent)`
	`1251`	`+ data, err := json.MarshalEscaped(pd, options.EscapeHTML)`
	`1252`	`+ if err != nil {`
	`1253`	`+ return nil, err`
	`1254`	`+ }`
	`1255`	`+`
	`1256`	`+ if indent == "" {`
	`1257`	`+ return data, nil`
`1243`	`1258`	`}`
`1244`	`1259`
`1245`		`- return json.Marshal(pd)`
	`1260`	`+ var buf bytes.Buffer`
	`1261`	`+ json.Indent(&buf, data, "", indent)`
	`1262`	`+ return buf.Bytes(), nil`
`1246`	`1263`	`}`
`1247`	`1264`
`1248`	`1265`	`// From http://tools.ietf.org/html/rfc6901#section-4 :`