{"(* :Title:  Arrow Graphics Primitives *)", "", 
 "(* :Context: Graphics`Arrow` *)", "", "(* :Author: John M. Novak *)", "", 
 "(* :Summary:  ", 
 "This package introduces the Arrow[start, finish] graphics", 
 "primitive and various style directives.", "*)", "", 
 "(* :Package Version: 1.0.3 *)", "", "(* :Mathematica Version: 2.2 *)", "", 
 "(* :Copyright: Copyright 1992-2005, Wolfram Research, Inc.*)", "", 
 "(* :History:", "\tV 0.9 June 1992 by John M. Novak.", 
 "\tV 1.0 October 1992 by John M. Novak--substantial revisions.", 
 "    V 1.0.1 March 1994 by John M. Novak -- bug fixes, including zero check"\
, "\t\t   in the PostScript.", 
 "    V 1.0.2 February 1997 by John M. Novak -- bug fix for DisplayString.", 
 "    V 1.0.3 February 1998 by John M. Novak -- fix to allow Arrow objects", 
 "           in Epilog or Prolog of any graphics object", "*)", "", 
 "(* :Keywords:", "\tArrow, Vector, PostScript, Graphics", "*)", "", 
 "(* :Sources:", "\tPostScript Language Reference Manual, Adobe Systems", 
 "*)", "", 
 "(* :Limitations:  Size of arrowhead cannot be taken into account", 
 "\tfor autoscaling of plot ranges, since determination of", 
 "\tplot ranges are done in Mathematica, and the arrow heads are", 
 "\tgenerated in pure PostScript. *)", "", "(* :Discussion: *)", "", 
 "BeginPackage[\"Graphics`Arrow`\"]", "", "Arrow::usage =", 
 "\"Arrow[start, finish, (opts)] is a graphics primitive representing an", 
 "arrow starting at start and ending at finish.\";", "", 
 "HeadShape::usage =", 
 "\"HeadShape is an option to the Arrow primitive; it specifies", 
 "the shape of the arrow's head by Automatic, which specifies that the", 
 "shape is described by the parameters HeadLength, HeadCenter, and", 
 "HeadWidth, or it can be a list of a subset of the Mathematica graphics", 
 "primitives, drawn in the coordinate system scaled by HeadScaling.  The", 
 "coordinate system is centered at the head of the arrow, with the negative", 
 "direction moving towards the tail of the arrow.\";", "", 
 "HeadScaling::usage =", 
 "\"HeadScaling is an option to the Arrow primitive; it specifies", 
 "the scaling used in the coordinate system for drawing the", 
 "arrowhead.  Automatic scales the system to the graphic, where", 
 "{0,0} is at the head of the arrow, and the system is rotated along", 
 "the arrow, and the distance between 0 and 1 is equivalent to the width of", 
 "the graphic.  Relative scales the coordinates of the arrowhead so that \
{0,0}", 
 "is at the head of the arrow, {-1,0} at the tail. Absolute scales to", 
 "the same coordinate system used in the device coordinate", 
 "system, rotated along the arrow, with {0,0} at the head.\";", "", 
 "ZeroShape::usage =", 
 "\"ZeroShape is an option to the Arrow primitive; it specifies", 
 "the shape of an arrow with no length (and hence no direction) in a form", 
 "similar to that of the HeadShape option.  Note that the", 
 "parameterized form of HeadShape is not available. The coordinate system", 
 "is not rotated, but is scaled to HeadScaling.  Automatic sets", 
 "the default zero arrow (a point.)\";", "", "HeadLength::usage =", 
 "\"HeadLength is an option to the Arrow primitive.  It is used when", 
 "HeadShape -> Automatic. It describes the length of the arrowhead, scaled", 
 "according to HeadScaling.\";", "", "HeadWidth::usage =", 
 "\"HeadWidth is an option to the Arrow primitive.  It is used when", 
 "HeadShape -> Automatic.  It describes the width of the arrowhead, relative"\
, "to the length of the arrowhead (specified by HeadLength.)\";", "", 
 "HeadCenter::usage =", 
 "\"HeadCenter is an option to the Arrow primitive.  It is used when", 
 "HeadShape -> Automatic.  It describes the location of the center of the ", 
 "base of the arrowhead along the length of the arrow, as a factor of the ", 
 "length of the arrowhead.  That is, if HeadCenter -> 0, the arrow will be ", 
 "two lines; if HeadCenter -> 1, the arrowhead will be a perfect triangle; ", 
 "otherwise, the arrowhead will be four-sided.\";", "", "Relative::usage =", 
 "\"Relative is a possible value for the HeadScaling option to Arrow.", 
 "It specifies that the coordinate system in which the arrowhead is rendered"\
, "should be scaled to the length of the arrow, where {0,0} is at the head", 
 "of the arrow and {-1,0} is at the tail of the arrow.\";", "", 
 "Absolute::usage =", 
 "\"Absolute is a possible value for the HeadScaling option to Arrow.", 
 "It specifies that the device scaling should be used for the", 
 "arrowhead.\";", "", "Begin[\"`Private`\"]", "", 
 "(* some global (but in private context) variables for caching the  arrow ", 
 "styles. *)", 
 "{$$HeadDescriptions, $$HeadRoutines, $$ZeroDescriptions, $$ZeroRoutines};", 
 "", "(* A little utility function for checking numeric values. *)", "", 
 "numberQ[x_] := NumberQ[N[x]]", "", "(* putting numbers in PostScript -", 
 "    To make it easy to put numbers into PostScript, this utility hacks the"\
, 
 "    PostScript operator.  Any number followed by a string is joined to the"\
, "    string in the proper format; a number at the end is turned into a \
string.", "*)", "", 
 "numtostring[num_]/;Abs[num] > 10^38 := numtostring[Sign[num] * 10^38]", "", 
 "numtostring[num_]/;Abs[num] < 10^-38 && Abs[num] > 0 :=", 
 "    numtostring[Sign[num] * 9.9999999^-37]", "", "numtostring[num_] :=", 
 "    ToString[NumberForm[N[num], 8,", 
 "            ExponentFunction -> (If[Abs[#] > 7, #, Null] &),", "            \
NumberFormat -> (If[#3 =!= \"\", StringJoin[#1, \"e\", #3], #1] &)", 
 "    ]]", "", "Unprotect[PostScript];", "", 
 "PostScript[x___, y_?numberQ] :=", "    PostScript[x,", 
 "        numtostring[y]]", "", 
 "PostScript[a___, y_?numberQ, z_String, b___] :=", "    PostScript[a,", 
 "        numtostring[y] <> \" \" <> z,", "        b", "    ]", "", 
 "Protect[PostScript]", "", "(* define PostScript operators *)", "", 
 "(* math to ps coordinates; note that this implementation is", 
 "used in part because of the sparsity of Mathematica PostScript", 
 "(e.g., transform does not exist.)  The MBeginOrig/MEndOrig", 
 "transform needs to be done every time, because this can be", 
 "different in a subgraph (i.e., I can't cache the transform", 
 "matrix once at the beginning.)  Because the transform operator", 
 "doesn't exist, I use this moveto method; unfortunately, this", 
 "requires the gsave/grestore, which undoubtedly leads to some", 
 "performance hit. *)", "", "mathtops =", "\tPostScript[", 
 "\t\t\"/mathtops {\",   (* stack: mathx mathy *)", "\t\t\t\"gsave\",", 
 "\t\t\t\"MBeginOrig\",", "\t\t\t\"moveto\",    (* stack: - *)", 
 "\t\t\t\"MEndOrig\",", "\t\t\t\"currentpoint\", (* stack : psx psy *)", 
 "\t\t\t\"grestore\",", "\t\t\"} bind def\"", "\t];", "", "tocoords =", 
 "\tPostScript[", 
 "\t\t\"/MAtocoords {\",   (* stack: beginx beginy endx endy *)", 
 "\t\t\t\"mathtops 4 2 roll mathtops\", (* x2 y2 x1 y1 *)", 
 "\t\t\t\"4 copy pop pop\",    (* x2 y2 x1 y1 x2 y2 *)", 
 "\t\t\t\"3 -1 roll sub\",     (* x2 y2 x1 x2 y2-y1 *)", 
 "\t\t\t\"/arry exch def\",", 
 "\t\t\t\"exch sub\",          (* x2 y2 x2-x1 *)", 
 "\t\t\t\"/arrx exch def\",", 
 "\t\t\t\"arrx dup mul\",    (* x2 y2 (x2-x1)^2 *)", 
 "\t\t\t\"arry dup mul\",   (* x2 y2 (x2-x1)^2 (y2-y1)^2 *)", 
 "\t\t\t\"add sqrt\",          (* x2 y2 (sqrt((x2-x1)^2+(y2-y1)^2) *)", 
 "\t\t\t\"/arrl exch def\",   (* x2 y2 *)", 
 "\t\t\t\"translate\",         (* - *)", "\t\t\"} bind def\"", "\t];", "", 
 "(* The following sets up the call to the doarrow routine. *)", "", 
 "Arrow::bad =", "\"Arguments `1` to Arrow are not valid.\";", "", 
 "Options[Arrow] =", "\t{HeadScaling -> Automatic,", 
 "\tHeadLength -> Automatic,", "\tHeadCenter -> 1,", "\tHeadWidth -> .5,", 
 "\tHeadShape -> Automatic,", "\tZeroShape -> Automatic};", "", 
 "evalarrow[{bx_?numberQ,by_?numberQ}, {ex_?numberQ,ey_?numberQ},", 
 "\t\topts:((_Rule | _RuleDelayed)...)] :=", 
 "\tModule[{head, zero, scale, len, cent, width,", 
 "\t\t\tnbx = N[bx], nby = N[by], nex = N[ex], ney = N[ey]},", 
 "\t\t{head, zero, scale, len, cent, width} = {HeadShape, ZeroShape,", 
 "\t\t\t\t\tHeadScaling, HeadLength, HeadCenter, HeadWidth}/.", 
 "\t\t\t{opts}/.Options[Arrow];", 
 "\t\tIf[numtostring[nbx] === numtostring[nex] &&", 
 "\t\t          numtostring[nby] === numtostring[ney],", 
 "\t\t\tarrow = generatezero[zero, scale, nbx, nby],", 
 "\t\t\tarrow = generatehead[head, scale, len, cent, width,", 
 "\t\t\t\t\t\tnbx, nby, nex, ney]", "\t\t];", 
 "\t\t{Line[{{bx,by},{ex,ey}}], arrow}", "\t ]", "", "evalarrow[args___] :=", 
 "\t(Message[Arrow::bad, {args}]; {})", "", 
 "(* This routine checks whether the arguments correspond to a cached ", 
 "arrowhead; if so, it returns the PostScript call to the routine.  If not,", 
 "it build the PostScript string, caches the arrow description and the", 
 "PostScript, and returns the PostScript call to the cached routine.  Note", 
 "that the preparearrows[] routine is the one to emit the cached routines.", 
 "*)", "", 
 "generatehead[head_, scale_, len_, cent_, width_, bx_, by_, nex_, ney_] :=", 
 "\tModule[{pos},", "\t\tIf[(pos = Position[$$HeadDescriptions, {head, scale, \
len, cent, width},", "\t\t\t\t\t\t\t{1}, Heads -> False]) != {},", 
 "\t\t\tPostScript[bx, by, nex, ney,", 
 "\t\t\t    \"MAarrowhead\"<>ToString[ pos[[1,1]] ]],", "\t\t(* else *)", 
 "\t\t\tbuildhead[head, scale, len, cent, width];", 
 "\t\t\tPostScript[bx, by, nex, ney,", 
 "\t\t\t    \"MAarrowhead\"<>ToString[Length[$$HeadRoutines]]]", "\t\t]", 
 "\t]", "", "generatezero[zero_, scale_, bx_, by_] :=", "\tModule[{pos},", 
 "\t\tIf[(pos = Position[$$ZeroDescriptions, {zero, scale},", 
 "\t\t\t\t\t\t\t{1}, Heads -> False]) != {},", 
 "\t\t\tPostScript[bx, by, \"MAarrowzero\"<>ToString[ pos[[1,1]] ]],", 
 "\t\t(* else *)", "\t\t\tbuildzero[zero, scale];", "\t\t\tPostScript[bx, by, \
\"MAarrowzero\"<>ToString[Length[$$ZeroRoutines]]]", "\t\t]", "\t]", "", 
 "(* These build the PostScript descriptions, and add descriptions to the", 
 "proper caching variables. *)", "", 
 "buildhead[head_, scale_, len_, cent_, width_] :=", 
 "\tModule[{routine, pshead},", 
 "\t\tAppendTo[$$HeadDescriptions, {head, scale, len, cent, width}];", 
 "\t\tIf[head === Automatic,", 
 "\t\t\tpshead = fromparams[scale, len, cent, width],", 
 "\t\t\tpshead = fromdescription[head]", "\t\t];", 
 "\t\troutine = {PostScript[\"gsave\", \"MAtocoords\", \"arrl 0. eq\",", 
 "\t\t\t\t\t\t\t  \"{ 0 0 Mdot }\", \"{\"], arrowscale[scale],", 
 "\t\t\trotatesystem, pshead, PostScript[\"} ifelse\", \"grestore\"]};", 
 "\t\tAppendTo[$$HeadRoutines, routine]", "\t]", "", 
 "buildzero[head_, scale_] :=", "\tModule[{routine, zhead, zscale},", 
 "\t\tAppendTo[$$ZeroDescriptions, {head, scale}];", 
 "\t\tIf[head === Automatic,", "\t\t\tzhead = PostScript[\"0 0 Mdot\"],", 
 "\t\t\tzhead = fromdescription[head]", "\t\t];", 
 "\t\tIf[scale === Absolute,", "\t\t\tzscale = arrowscale[scale],", 
 "\t\t\tzscale = {}", "\t\t];", 
 "\t\troutine = {PostScript[\"gsave\", \"mathtops translate\"], zscale,", 
 "\t\t\tzhead, PostScript[\"grestore\"]};", 
 "\t\tAppendTo[$$ZeroRoutines, routine]", "\t]", "", 
 "(* PostScript for rotating coordinate system *)", "", "rotatesystem =", 
 "\tPostScript[", "\t\t\"[ arrx arrl div\",   (* [ cos(t) *)", 
 "\t\t\"arry arrl div\",    (* [ cos(t) sin(t) *)", 
 "\t\t\"-1 arry mul arrl div\",", "\t\t\"arrx arrl div\",", 
 "\t\t\"0 0 ]\",             (* [cos(t) sin(t) -sin(t) cos(t) 0 0] *)", 
 "\t\t\"concat\"             (* - *)", "\t];", "", "", 
 "(* This generate the primitives describing a parameterized arrowhead. *)", \
"(* fromparams determines the default length parameter depending on scaling; \
it", "\tcalls fromsparams *)", "", 
 "fromparams[Automatic, Automatic, c_, w_] :=", "\tfromsparams[.05, c, w]", 
 "", "fromparams[Relative, Automatic, c_, w_] :=", "\tfromsparams[.2, c, w]", 
 "", "fromparams[Absolute, Automatic, c_, w_] :=", "\tfromsparams[15, c, w]", 
 "", "fromparams[_, l_, c_, w_] := fromsparams[l,c,w]", "", 
 "fromsparams[l_, _?(#==0&), w_] :=", "\tPostScript[", 
 "\t\t-l, (w l)/2, \" moveto 0 0 lineto \",", 
 "\t\t-l, -(w l)/2, \" lineto stroke\"", "\t]", "", 
 "(* note that filled arrowheads are outlined by a line to hopefully cause a"\
, "\tmore graceful resizing... *)", "fromsparams[l_, _?(#==1&), w_] :=", 
 "\tModule[{nls = -l, ws = (w l)/2, nws = -(w l)/2},", "\t\tPostScript[", 
 "\t\t\tnls, ws, \"moveto 0 0 lineto\",", "\t\t\tnls, nws, \"lineto fill\",", 
 "\t\t\tnls, ws, \"moveto 0 0 lineto\",", "\t\t\tnls, nws, \"lineto\",", 
 "\t\t\tnls, ws, \"lineto stroke\"", "\t\t]", "\t]", "", 
 "fromsparams[l_, c_, w_] :=", 
 "\tModule[{nls = -l, ncs = -c l, ws = (w l)/2, nws = -(w l)/2},", 
 "\t\tPostScript[", "\t\t\tnls, ws, \"moveto 0 0 lineto\",", 
 "\t\t\tnls, nws, \"lineto\",", "\t\t\tncs, \"0 lineto fill\",", 
 "\t\t\tnls, ws, \"moveto 0 0 lineto\",", "\t\t\tnls, nws, \"lineto\",", 
 "\t\t\tncs, \"0 lineto\",", "\t\t\tnls, ws, \"lineto stroke\"", "\t\t]", 
 "\t]", "", 
 "(* Create PostScript from a Mathematica-like syntax for describing head *)"\
, "", "fromdescription[head_] := head/.{Polygon[g_] :> frompoly[g],", 
 "\tLine[l_] :> fromline[l],", "\tPoint[p_] :> frompoint[p],", 
 "\tThickness[t_] :> PostScript[t, \"w\"]}", "", "frompoly[g_] :=", 
 "\tModule[{str = listtostring[g]},", "\t\tPostScript[", "\t\t\tstr,", 
 "\t\t\t\"fill\"", "\t\t]", "\t]", "", "fromline[g_] :=", 
 "\tModule[{str = listtostring[g]},", "\t\tPostScript[", "\t\t\tstr,", 
 "\t\t\t\"stroke\"", "\t\t]", "\t]", "", "frompoint[{x_,y_}] :=", 
 "\tPostScript[", "\t\tx, y, \"Mdot\"", "\t]", "", "listtostring[l_] :=", 
 "\tWith[{initial = numtostring[#1]<>\" \"<>numtostring[#2]<>", 
 "\t\t\t\" moveto \" & @@ First[l]},", 
 "\t\tFold[#1<>numtostring[First[#2]]<>\" \"<>numtostring[Last[#2]]<>", 
 "\t\t\t\t\" lineto \"&,initial, Rest[l]", "\t\t]", "\t]", "", 
 "(* PostScript for coordinate scaling for arrowhead *)", "", 
 "HeadScaling::bad =", "\"Arguments `1` to HeadScaling are not Automatic, \
Relative, or Absolute; using", "default of Automatic.\";", "", 
 "arrowscale[] := arrowscale[Automatic]", "", "arrowscale[Automatic] := {}", 
 "", "arrowscale[Relative] :=", "\tPostScript[", "\t\t\"arrl arrl scale\"", 
 "\t]", "", "arrowscale[Absolute] :=", "\tPostScript[", 
 "\t\t\"currentlinewidth 1 Mabswid\",", 
 "\t\t\"currentlinewidth dup scale setlinewidth\"", "\t]", "", 
 "arrowscale[x___] :=", 
 "\t(Message[HeadScaling::bad, {x}]; arrowscale[Automatic])", "", "(* \
generate PostScript from cached descriptions, set up routines for preparing", 
 "to do arrows (This gets dumped into the start of the Prolog. *)", "", 
 "preparearrows[] := ", "\tModule[{heads, zeros},", 
 "\t\theads = MapIndexed[", 
 "\t\t\t{PostScript[\"/MAarrowhead\"<>ToString[First[#2]]<>\" {\"],", 
 "\t\t\t #1, PostScript[\"} def\"]}&, $$HeadRoutines];", 
 "\t\tzeros = MapIndexed[", 
 "\t\t\t{PostScript[\"/MAarrowzero\"<>ToString[First[#2]]<>\" {\"],", 
 "\t\t\t #1, PostScript[\"} def\"]}&, $$ZeroRoutines];", 
 "\t\tFlatten[{mathtops, tocoords, heads, zeros}]//.", 
 "\t\t\t{x___, PostScript[a___], PostScript[b___], y___} :>", 
 "\t\t\t\t{x,PostScript[a,b], y}", "\t]", "", 
 "(* remember that all the $$etc. are global... *)", 
 "(* was originally coded to only operate on Graphics objects, but it", 
 "   turns out that Arrow objects can work in Epilog or Prolog, so at", 
 "   cost of poorer error checking, the code was trivially modified to", 
 "   check anything being passed to Display for an Arrow. This may", 
 "   mean trouble for design of a 3D arrow, if it shares the head Arrow. *)", 
 "Unprotect[Display];", "", "Display[stream_,", 
 "\t\t((ghead_)[igarg_, igopts___])?", "\t\t\t\t\t(!FreeQ[#,Arrow]&),", 
 "\t\topts___] :=", "\tModule[{oldgropts, oldgaopt, prolog, p},", 
 "\t\t$$HeadDescriptions = {}; $$HeadRoutines = {}; $$ZeroDescriptions ={};", 
 "\t\t$$ZeroRoutines = {};", "\t\tUnprotect[Graphics,GraphicsArray];", 
 "\t\toldgropts = Options[Graphics];", 
 "\t\toldgaopts = Options[GraphicsArray];", 
 "\t\tOptions[Graphics] = Options[Graphics]/.", 
 "\t\t\t\tArrow[p___] :> evalarrow[p];", 
 "\t\tOptions[GraphicsArray] = Options[GraphicsArray]/.", 
 "\t\t\t\tArrow[p___] :> evalarrow[p];", 
 "\t\tprolog = (Prolog/.Flatten[{igopts}]/.Options[ghead])/.", 
 "\t\t\t\t\tArrow[p___] :> evalarrow[p];", 
 "\t\tgarg = igarg/.Arrow[p___] :> evalarrow[p];", 
 "\t\tgopts = {igopts}/.Arrow[p___] :> evalarrow[p];", 
 "\t\tIf[Head[prolog] === List,", "\t\t\tprolog = Join[preparearrows[],", 
 "\t\t\t\tprolog],", "\t\t\tprolog = Append[preparearrows[], prolog]", 
 "\t\t];", "\t\tDisplay[stream,", 
 "\t\t\tghead[garg, Flatten[{Prolog -> prolog, Sequence @@ gopts}]],", 
 "\t\t\topts", "\t\t];", "\t\tUnprotect[Graphics, GraphicsArray];", 
 "\t\tOptions[Graphics] = oldgropts;", 
 "\t\tOptions[GraphicsArray] = oldgaopts;", 
 "\t\tProtect[Graphics, GraphicsArray];", "\t\tghead[igarg,igopts]", "\t]", 
 "", "Protect[Display];", "", "Unprotect[DisplayString];", "", 
 "DisplayString[", "\t\t((ghead_)[igarg_, igopts___])?", 
 "\t\t\t\t\t(!FreeQ[#,Arrow]&),", "\t\topts___] :=", 
 "\tModule[{oldgropts, oldgaopt, prolog, p, grout},", 
 "\t\t$$HeadDescriptions = {}; $$HeadRoutines = {}; $$ZeroDescriptions ={};", 
 "\t\t$$ZeroRoutines = {};", "\t\tUnprotect[Graphics,GraphicsArray];", 
 "\t\toldgropts = Options[Graphics];", 
 "\t\toldgaopts = Options[GraphicsArray];", 
 "\t\tOptions[Graphics] = Options[Graphics]/.", 
 "\t\t\t\tArrow[p___] :> evalarrow[p];", 
 "\t\tOptions[GraphicsArray] = Options[GraphicsArray]/.", 
 "\t\t\t\tArrow[p___] :> evalarrow[p];", 
 "\t\tprolog = (Prolog/.Flatten[{igopts}]/.Options[ghead])/.", 
 "\t\t\t\t\tArrow[p___] :> evalarrow[p];", 
 "\t\tgarg = igarg/.Arrow[p___] :> evalarrow[p];", 
 "\t\tgopts = {igopts}/.Arrow[p___] :> evalarrow[p];", 
 "\t\tIf[Head[prolog] === List,", "\t\t\tprolog = Join[preparearrows[],", 
 "\t\t\t\tprolog],", "\t\t\tprolog = Append[preparearrows[], prolog]", 
 "\t\t];", "\t\tgrout = DisplayString[", 
 "\t\t\tghead[garg, Flatten[{Prolog -> prolog, Sequence @@ gopts}]],", 
 "\t\t\topts", "\t\t];", "\t\tUnprotect[Graphics, GraphicsArray];", 
 "\t\tOptions[Graphics] = oldgropts;", 
 "\t\tOptions[GraphicsArray] = oldgaopts;", 
 "\t\tProtect[Graphics, GraphicsArray];", "\t\tgrout", "\t]", "", 
 "Protect[DisplayString];", "", "(* OK, this is an ugly hack for several \
\"graphic characteristic determination\"", 
 "   functions (FullOptions, FullGraphics, FullAxes, PlotRange).", 
 "   This is not a complete solution, since it doesn't spot Arrows that are", 
 "   set in default options. Also, FullGraphics is (for the time being) not", 
 "   being handled, since that would involve generating the proper \
PostScript", 
 "   primitives. Hopefully, this will all be able to be supersceded by some", 
 "   kernel design, so I am only making this temporary fix. --JMN, 10.93", 
 "*)", "", "Unprotect[FullAxes];", "", 
 "FullAxes[gr_?(!FreeQ[#,Arrow]&), rest___] :=", 
 "   FullAxes[gr/.Arrow[beg_, end_, ___] :> Line[{beg, end}], rest]", "", 
 "Protect[FullAxes];", "", "Unprotect[PlotRange];", "", 
 "PlotRange[gr_?(!FreeQ[#,Arrow]&), rest___] :=", 
 "   PlotRange[gr/.Arrow[beg_, end_, ___] :> Line[{beg, end}], rest]", "", 
 "Protect[PlotRange];", "", "Unprotect[FullOptions]", "", 
 "FullOptions[gr_?(!FreeQ[#,Arrow]&), rest___] :=", 
 "   FullOptions[gr/.Arrow[beg_, end_, ___] :> Line[{beg, end}], rest]", "", 
 "Protect[FullOptions];", "", "", "End[]", "", "EndPackage[]"}
