var _ error = mapError{}
var _ error = new(mapError)

func TestImplements(t *testing.T) {
	for _, tt := range implementsTests {
		xv := TypeOf(tt.x).Elem()
		xt := TypeOf(tt.t).Elem()
		if b := xv.Implements(xt); b != tt.b {
			t.Errorf("(%s).Implements(%s) = %v, want %v", TypeString(xv), TypeString(xt), b, tt.b)
		}
	}
}

var assignableTests = []struct {
	x any
	t any
	b bool
}{

	hdrValueSlice []*[]*Value
	hdrInt64Slice []*[]int64
}

func (c *Cache) Reset() {
	nv := sort.Search(len(c.values), func(i int) bool { return c.values[i].ID == 0 })
	xv := c.values[:nv]
	for i := range xv {
		xv[i] = Value{}
	}
	nb := sort.Search(len(c.blocks), func(i int) bool { return c.blocks[i].ID == 0 })
	xb := c.blocks[:nb]
	for i := range xb {
		xb[i] = Block{}
	}

	Pos() token.Pos
	End() token.Pos
	exprNode()
}

func TestImplements(t *testing.T) {
	for _, tt := range implementsTests {
		xv := TypeOf(tt.x).Elem()
		xt := TypeOf(tt.t).Elem()
		if b := xv.Implements(xt); b != tt.b {
			t.Errorf("(%s).Implements(%s) = %v, want %v", xv.String(), xt.String(), b, tt.b)
		}
	}
}

var assignableTests = []struct {
	x any
	t any
	b bool
}{

// It panics if v is not a JavaScript object.
func (v Value) Set(p string, x any) {
	if vType := v.Type(); !vType.isObject() {
		panic(&ValueError{"Value.Set", vType})
	}
	xv := ValueOf(x)
	valueSet(v.ref, p, xv.ref)
	runtime.KeepAlive(v)
	runtime.KeepAlive(xv)
}

// valueSet sets property p of ref v to ref x.
//
// (noescape): This is safe because no references are maintained to the

// And x (interface storage) doesn't need to escape.
func append1(s []int, x int) []int { // ERROR "leaking param: s$"
	sv := reflect.ValueOf(s)     // ERROR "s escapes to heap"
	xv := reflect.ValueOf(x)     // ERROR "x escapes to heap"
	rv := reflect.Append(sv, xv) // ERROR "... argument does not escape"
	return rv.Interface().([]int)
}

// Unfortunate: s doesn't need escape, only leak to result.

00000290  21 5d 3e a3 1e be 4e 0b  ce 10 ab 61 a5 76 ef 62  |!]>...N....a.v.b|
000002a0  50 1b 52 a8 75 23 fd eb  ea 76 f9 d8 41 3c a2 e4  |P.R.u#...v..A<..|
000002b0  21 cb 56 f7 40 81 78 56  22 06 2a 38 fc 1f d8 9f  |!.V.@.xV".*8....|
000002c0  38 b0 7a 93 f0 8c ad 3e  54 27 a2 d7 8b 2c 79 46  |8.z....>T'...,yF|
000002d0  15 65 f1 55 b2 2a 06 a1  97 9b 47 23 f8 9a 3f 88  |.e.U.*....G#..?.|

00000160  a1 f2 0d 19 e7 d8 a8 6d  cd ea f6 82 ee 5d 0a 55  |.......m.....].U|
00000170  22 61 11 21 f7 b0 1d 86  a8 4d c2 e2 9b ac bb 87  |"a.!.....M......|
00000180  a2 82 67 ee 78 76 9b e0  c0 00 85 bf 1e 2b ab e6  |..g.xv.......+..|
00000190  f1 43 79 69 a0 3d 04 b7  d9 7f 31 c7 7a b7 4f 5c  |.Cyi.=....1.z.O\|
000001a0  9f 62 84 dc f4 6d a1 ce  3d ff 24 88 15 10 4a e6  |.b...m..=.$...J.|

		if tn, xn := t.NumParams(), x.NumParams(); tn != xn {
			return cmpForNe(tn < xn)
		}
		if tn, xn := t.NumResults(), x.NumResults(); tn != xn {
			return cmpForNe(tn < xn)
		}
		if tv, xv := t.IsVariadic(), x.IsVariadic(); tv != xv {
			return cmpForNe(!tv)
		}

		tfs := t.RecvParamsResults()
		xfs := x.RecvParamsResults()
		for i, tf := range tfs {
			if c := tf.Type.cmp(xfs[i].Type); c != CMPeq {

				"application/xml-external-parsed-entity",
				"application/xmpp+xml",
				"application/xop+xml",
				"application/xslfo+xml",
				"application/xslt+xml",
				"application/xspf+xml",
				"application/xv+xml",
				"application/zip",
				"application/x-7z-compressed",
				"audio/32kadpcm",
				"audio/3gpp",
				"audio/3gpp2",
				"audio/ac3",
				"audio/adpcm",
				"audio/amr",

'�J�0�0Jf��(4���U5L�hz��R�F���R���OS�� i�=@��%@=@2>��(�5[ �Ѵږ�[�92Y�*�Ŀ���=�Y�r@a-$ �"J�E���[QA-������RP�j(!�;6S��l���8�Vj�U�Y���)�1(��8�\ɘ��U0cH�Fgm$�xx�8��D4��z�I��]�!��J�Z�(R���DȒ�R��kҚ�@3+*(k5̬���
������m���H�4I��A��XV�aY4ls����4X�b��V1JR���7 �q.\Wr�Q;l��[U�ű���(mDhњZ�),���S$�S ��,��`ǖ����U�����$4�L�լ� �E �tE�Y\���IحF�'l�*�I#CiI�&�H�q1���$��I�h�L�uF)L��#9�ZJ�T�|�F�tղ�7��j��$I��dD�L�5�ߜQ&+�q�6ۭ��O ��TV5VS`�Nf�h�2�`s$�'SkUp���KF�U��d�#3�G$�� ��t�...