{"id":78,"date":"2026-04-07T10:25:58","date_gmt":"2026-04-07T10:25:58","guid":{"rendered":"https:\/\/permacomputer.solarpunk.au\/?p=78"},"modified":"2026-04-11T11:18:16","modified_gmt":"2026-04-11T11:18:16","slug":"edit-bas","status":"publish","type":"post","link":"https:\/\/permacomputer.solarpunk.au\/?p=78","title":{"rendered":"EDIT.BAS"},"content":{"rendered":"\n

Text Editor Prevents “Starvation” and Programming Hassles<\/h2>\n\n\n\n

By Donald Fitchhorn<\/h3>\n\n\n\n

MITS<\/h3>\n\n\n\n

Computer Notes, October 1977.<\/h3>\n\n\n\n

Why I wrote an editor<\/h2>\n\n\n\n

My main objective in writing an editor was to complement DISK EXTENDED BASIC’s built-in EDIT feature. This feature is invaluable if the location of a needed change is already known. But what about our friend Bob’s problem? He knew WHAT the problem was but not WHERE to find it. What he needs is a program that will search through the entire file until it finds what he wants. Since there isn’t such an editor in Disk Extended BASIC, I wrote my own in BASIC so that it can be easily changed.<\/p>\n\n\n\n

The search command and others like it where the beginnings of my editor, which now has 14 commands. But before we get into an explanation of this editor, let’s review the definition of an editor.<\/p>\n\n\n\n

What is an editor?<\/h2>\n\n\n\n

An editor is a program which permits the addition and deletion of lines and characters in one file to make another file. The second file is the new up-to-date file, and the first file is retained as the backup file. Some editors permit the creation of new files and\/or use multiple input files. An editor can be as extensive or as minimal as is necessary for an application.<\/p>\n\n\n\n

PROGRAM FILES<\/h2>\n\n\n\n

The EDIT program works on ASCII program files. A program file is any file that looks like a program to BASIC. (see EXAMPLE 1.) BASIC doesn’t care if the whole file is REMark statements; it’s only concerned with whether or not there is a line number at the beginning of each line. (See EXAMPLE 2.)<\/p>\n\n\n\n

(NOTE: The EDIT program cannot handle files saved in binary. Save all files in ASCII, i.e. SAVE \"FILENAME\", 0, A<\/code>)<\/p>\n\n\n\n

EXAMPLE #1<\/code><\/p>\n\n\n\n

10 'THIS IS A PROGRAM FILE\n20 FOR I = 1 TO 100000\n30 PRINT I;RND(I)*1000;I*RND(I)\n40 ' THIS PRINTS SOME NUMBERS\n50 NEXT\n60 END\n<\/pre>\n\n\n\n
EXAMPLE #2<\/code><\/p>\n\n\n\n
10 'This is a document program file\n20 'here is the\n30 'text of the\n40 'document !\n50 'this is the end.\n<\/pre>\n\n\n\n
EXAMPLE #3\nLOWER CASE IS USER TYPED\n\nrun\"edit\nEDIT -- VERSION 1.0\nINPUT FILE NAME?time\n>r\nEOF1\nCLEARING..........\n>\/1\n5 LPRINT\"MINUTES\",\"HUNDREDTHS\",,\"MINUTES\",\"HUNDREDTHS\"\n10 FORI=6TO30STEP-1\n20 J=INT(I\/60*100)\n21 K=INT((I\/30)\/60*100)\n30 LPRINTI,J,,I-30,K\n40 NEXT\n>gJ\n20 J\n>cL2\n30 L2=INT(I\/60*100)\n>gJ\n30 LPRINTI,J\n>cL2\n30 LPRINTI,L2,,I-30,K\n>gJ\nEOB\n>x\nBACKUP FILE NAME?time.bak\nOK\nload\"time\nOK\nlist\n5 LPRINT\"MINUTES\",\"HUNDREDTHS\",,\"MINUTES\",\"HUNDREDTHS\"\n10 FOR I=60TO30STEP-1\n20 J=INT(I\/60*100)\n21 K=INT((I-30)\/60*100)\n30 LPRINTI,J,,I-30,K\n40 NEXT\nOK\n<\/code><\/pre>\n\n\n\n
Saving documents as programs (EXAMPLE 2 format) allows them to be loaded with BASIC. This allows BASIC to be used to alter, delete, and add lines. Of course, line numbers on the finished document may not be wanted, so a short program that reads the file and PRINTs MID$(LINE$, INSTR(LINE$,\"'\")+1<\/code> will print everything to the right of the (‘). Be sure to use LINE INPUT<\/code> instead of INPUT<\/code> when reading up LINE$<\/code> to prevent truncation because of commas in the text. The (‘)’s in EXAMPLE 2 are necessary if the program file is to be loaded and saved by BASIC. Without the (‘), BASIC will modify the text line.<\/p>\n\n\n\n
BASIC won’t allow lines to be moved around within the file without retyping each line. But with the EDIT program, line numbers can be changed to whatever is wanted. When the edited file is loaded into BASIC, BASIC will put the lines in numerical order.<\/p>\n\n\n\n
Internal structure<\/h2>\n\n\n\n
The EDIT program maintains a double-linked list in memory. Each line (L1$(X)<\/code>) has a pointer to the previous line [M1(X,0)<\/code>] and to the next line [M1(X,1)<\/code>] added to it when it is read in. The array (L1$) that the lines are kept in is divided into two parts — ACTIVE CELLS, which have data in them, and INACTIVE CELLS, available for use as data lines. Deleted lines are linked into the INACTIVE CELLS from the ACTIVE CELLS. Inserted lines are written into the first available INACTIVE CELL and then linked into the ACTIVE CELLS. Pointers are maintained for FIRST ACTIVE CELL (LN), FIRST INACTIVE CELL (IN), DOT or position within cell (H) and CELL that DOT is in (J).<\/p>\n\n\n\n
Commands<\/h2>\n\n\n\n
My editor, like many others, uses a single letter to select a command. For example, A<\/code> will advance DOT one line. Most commands may be preceded by a number or a slash (\/) to indicate that hey should be executed more than once. 13A will advance DOT 13 lines. OA will position DOT at the beginning of the current line. \/A will advance DOT to the end of the page. All commands that allow a prefix will default to one if none is specified. The following is an explanation of the commands. (See TABLE 1 for a list of commands in alphabetical order. See TABLE 2 for a list divided into four main groups).<\/p>\n\n\n\n
TABLE #1\n\n                    |-------OPERATES ON --------|--- ALLOWED ---|\nCOMMAND DESCRIPTION | LINE | CHAR | DOT  | FILE | 0 | # |-# | \/ |\n--------------------|------|------|------|------|---|---|---|---|\n   A    ADVANCE     |      |      |  *   |      | * | * | * | * |\n--------------------|------|------|------|------|---|---|---|---|\n   B    BEGINNING   |      |      |  *   |      |   |   |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   C    CHANGE      |      |  *   |      |      |   |   |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   D    DELETE      |      |  *   |      |      |   | * |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   E    END         |      |      |  *   |      |   |   |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   G    GET         |      |  *   |      |      |   | * |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   I    INSERT      |  *   |  *   |      |      |   |   |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   J    JUMP        |      |      |  *   |      | * | * | * |   |\n--------------------|------|------|------|------|---|---|---|---|\n   K    KILL        |  *   |      |      |      |   | * |   | * |\n--------------------|------|------|------|------|---|---|---|---|\n   L    LIST        |  *   |      |      |      |   | * |   | * |\n--------------------|------|------|------|------|---|---|---|---|\n   N    NEXT        |      |      |      |  *   |   |   |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   R    READ        |      |      |      |  *   |   |   |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   V    VERIFY      |  *   |      |      |      |   |   |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n   X    EXIT        |      |      |      |  *   |   |   |   |   |\n--------------------|------|------|------|------|---|---|---|---|\n\n<\/code><\/pre>\n\n\n\n
<\/p>\n\n\n\n
TABLE #2\nCOMMANDS THAT AFFECT LINES\nI - Inserts lines until, backslash (\\) is entered.\nK - Kills entire line. #K & \/K are legal.\nL - Lists entire line. #L & \/L are legal.\nV - Prints the current line up to DOT.\n    (Verify's the position of DOT).\n\nCOMMANDS THAT AFFECT CHARACTERS\nC - Changes last character string gotten with G command to\n    something else. Use: Ghere\n                         Cthere\n    will change here to there.\nD - Delete a character. #D legal.\nG - Get string. Searches for occurrence of string.\n    Use: 3Gstuff\n    Finds third occurrrence of stuff. #G legal.\nI - Insert characters at DOT. Use: Iabcde\n    Will insert abcde in current line at DOT.\n\nCOMMANDS THAT MOVE DOT\nA - Moves DOT forward or back the number of lines\n    specified. 0A, #A, -#A, \/A(same as E) legal.\nB - Moves DOT to beginning of page .\nE - Moves DOT to end of page. (same as \/A)\nJ - Moves DOT forward or back the number of characters\n    specified. 0J, #J, -#J legal.\n\nCOMMANDS THAT READ AND WRITE THE FILE\nN - Writes out current page and reads in next page.\nR - Read in a new page.\nX - Writes out current page then reads and writes until\n    end of file. Closes and renames files.\n<\/code><\/pre>\n\n\n\n
How to use edit’s commands<\/h2>\n\n\n\n
The commands in EDIT are broken up into four groups, as shown in TABLE 2. The use of these commands will be explained in that order.<\/p>\n\n\n\n
The commands that affect lines will work on one line at a time. Or, in the case of K & L, they may be preceded by a number or slash (\/) to indicate that they are to be performed on several succeeding lines. TO begin insertion of lines, type I <return><\/code> and then the lines to insert. To tell EDIT that the last line to be inserted has been entered, type backslash ().<\/p>\n\n\n\n
Of the commands that affect characters I & C cannot have a # prefix. #D deletes # characters to the right of DOT. G & C work together to allow getting a string and then changing it to something else. G moved DOT ahead of the Nth occurrence of the string. Then C can be used to change the nth occurrence to a new string. It works like C, except instead of changing one string for another, it inserts a new string ahead of DOT.<\/p>\n\n\n\n
The commands that move DOT are A, B, E, and J. B & E require no other specifiers. They simply move DOT to the beginning or end of the current page. A & J move DOT forward or back a specified number of lines or characters.<\/p>\n\n\n\n
The commands N, R, and X read and write the files. R reads the input file until EOF, until it has read 50 lines, or 2000 characters. It then clears and resets the INACTIVE CELLS. N writes out the current page and then executes and R (reads in the next page). X does a series of N’s until the input file is EOF. Then it closes the files and renames them by giving the input file a backup name and the output file the input file’s old name.<\/p>\n\n\n\n
The best way to learn to use EDIT is to load it in and try a few commands. (See EXAMPLE 3). Once you get the hang of it, the power and versatility will be well worth the time it took t type it in.<\/p>\n\n\n\n
The other side of the coin<\/h2>\n\n\n\n
All of the above is really wonderful isn’t it? But this program is not without its limitations.<\/p>\n\n\n\n
    \n
  1. The commands may or may not work the way the user expects them to. This is a typical problem in any new program because the commands take some getting used to. If, after trying it for a while, the user wants a command to work differently or wants to use another command, just remember that the program is written in BASIC, so modifications are easy.<\/li>\n\n\n\n
  2. The program allows working on large files by breaking the file into pages. This works out well except for one thing. No matter what the user does, string space is used. Eventually, all available space will be used. At that time, BASIC has to look through all of the string space, shuffling things around and freeing up no-longer-used bytes so that the program will have some more space. This is commonly referred to as GARBAGE COLLECTING. IT can happen at the most unlikely of times and can take as long as five minutes. Unfortunately to the unsuspecting user, it looks as though the program has bombed BASIC out because CTRL-C and RESET don’t help solve the problem. But patience is rewarded and the program does come back to life.<\/li>\n<\/ol>\n\n\n\n
    Modifications and improvements<\/h2>\n\n\n\n
    I will leave these up to the reader because they are easy to make. For example, suppose a command is needed to exit the program gracefully without making any changes. Follow these steps:<\/p>\n\n\n\n
      \n
    1. Pick a command character. How about Q for quit?<\/li>\n\n\n\n
    2. Alter line 250 to reflect where the program should go if it sees a Q. Let’s make this 1000.<\/li>\n\n\n\n
    3. Put in the necessary code to perform the command. 1000 CLOSE:CLEAR 200:END<\/li>\n\n\n\n
    4. Save the new program.<\/li>\n<\/ol>\n\n\n\n
      PROGRAM LISTING<\/h1>\n\n\n\n
      10 '                 == WRITTEN BY D. L. FITCHHORN ==\n15 '                =   *****  ****   *****  *****   =\n20 '               =    *      *   *    *      *      =\n25 '              =     ***    *   *    *      *       =\n30 '               =    *      *   *    *      *      =\n35 '                =   *****  ****     *      *     =\n40 '                 ==   PROGRAMMER - MITS, INC   ==\n45 '\n50 DEFINT A-Z\n55 CLEAR 15000\n60 DIM L1$(100),L2$(13),M1(100,1):FOR I=0 TO 13:READ L2$(I):NEXT\n65 DATA \n   A - ADVANCE,B - BEGINNING,C - CHANGE,D - DELETE,E - END,G - GET,I - INSERT,\n   J - JUMP, K - KILL,L -LIST,N = NEXT,R - READ,V - VERIFY,X - EXIT\n70 PRINT \"EDIT -- VERSION 1.0\":PRINT\n75 LINE INPUT \"INPUT FILE NAME?\"; N1$\n80 OPEN \"I\",1,N1$\n85 N2$=\"EDIT.TMP\"\n90 OPEN \"O\",2,N2$:PRINT #2,\"\"\n95 I=1:J=1:H=1\n100 '---------------------------------------------------------INPUT COMMAND\n105 K=0\n110 IF A$=\"\" THEN FOR Q9=1 TO 5:PRINT CHR$(7);:NEXT:LINE INPUT \">\"; A$\n115 A=0:J1=1:U=0:T=1\n120 IF A$=\"\" THEN 105 ELSE I9=INSTR(A$,\"\\\\\"):IF I9<>0 THEN S$=LEFT$(A$,I9-1):\n    A$=MID$(A$,I9+1) ELSE S$=A$:A$=\"\"\n125 SS=ASC(S$)\n130 IF 64<SS THEN IF 96<SS THEN SS=SS-32:GOTO 170 ELSE GOTO 170\n135 T=VAL(S$)\n140 S=LEN(STR$(T))\n145 IF T=0 THEN IF LEFT$(S$,1)=\"\/\" THEN T=400\n150 S$=MID$(S$,S)\n155 IF T<0 THEN S$=MID$(S$,2)\n160 GOTO 125\n165 '             .A  .B  .C  .D  .E  <F> .G  <H> .I  .J  .K  .L  <M>\n170 ON SS-64 GOTO 195,235,245,265,280,180,290,180,320,360,385,425,180,\n                  445,180,180,180,465,180,180,180,515,180,525,180,180\n175 '             .N  <O> <P> <Q> .R  <S> <T> <U> .V  <W> .X  <Y> <Z>\n180 FOR N=0 TO 12:PRINT L2$(N):NEXT:GOTO 105\n185 '\n190 '-----------------------------------------------------------A COMMAND\n195 H=1:IF T=0 THEN GOTO 105 ELSE IF T<0 THEN J1=-1\n200 FOR I3=0 TO T-J1 STEP J1\n205     IF M1(J,0)=0 AND J1=-1 THEN GOTO 105\n210     IF M1(J,1)=-1 AND J1=1 THEN J=M1(J,0):GOTO 105\n215     IF J1=1 THEN J=M1(J,1) ELSE J=M1(J,0)\n220 NEXT\n225 GOTO 105\n230 '-----------------------------------------------------------B COMMAND\n235 J=LN:H=1:GOTO 105\n240 '-----------------------------------------------------------C COMMAND\n245 S$=MID$(S$,2):IF K=0 THEN S=LEN(S$):K=H\n250 IF K=1 THEN L1$(J)=S$+MID$(L1$(J),K+S) ELSE L1$(J)=LEFT$(L1$(J),K-1)+\n    S$+MID$(L1$(J),K+S)\n255 PRINT L1$(J):H=K+LEN(S$):GOTO 105\n260 '-----------------------------------------------------------D COMMAND\n265 IF H=1 THEN L1$(J)=MID$(L1$(J),H+T):\n    ELSE L1$(J)=LEFT$(L1$(J),H-1)+MID$(L1$(J),H+T)\n270 GOTO 105\n275 '-----------------------------------------------------------E COMMAND\n280 IF M1(J,1)=-1 THEN H=1:GOTO 105 ELSE J=M1(J,1):GOTO 280\n285 '-----------------------------------------------------------G COMMAND\n290 S$=MID$(S$,2):S=LEN(S$):IF S=0 THEN GOTO 105\n295 K=INSTR(H,L1$(J),S$):IF K=0 THEN IF M1(J,1)=-1\n    THEN PRINT \"EOB\":A$=\"\":GOTO 105 ELSE J=M1(J,1):H=1:GOTO 295\n300 U=U+1:IF U<T THEN H=K+S:GOTO 295\n305 PRINT LEFT$(L1$(J),K+S-1):H=K\n310 GOTO 110\n315 '-----------------------------------------------------------I COMMAND\n320 IF MID$(S$,2)<>\"\" THEN 345 ELSE I2=J:IF J=LN THEN LN=IN\n325 LINE INPUT L1$(IN):IF L1$(IN)\"\\\\\" THEN 105\n330 I3=M1(IN,1):M1(IN,1)=I2\n335 M1(IN,0)=M1(I2,0):M1(I2,0)=IN:I4=M1(IN,0)\n340 M1(I4,1)=IN:IN=I3:M1(I3,0)=0:GOTO 325\n345 IF H1=1 THEN L1$(J)=MID$(S$,2)+L1$(J) \n    ELSE L1$(J)=LEFT$(L1$(J),H-1)+MID$(S$,2)+MID$(L1$(J),H)\n350 H=H+LEN(S$):GOTO 105\n355 '-----------------------------------------------------------J COMMAND\n360 IF T=0 THEN H=1:GOTO 105\n365 H=H+T:IF H<1 THEN H=1\n370 IF H>LEN(L1$(J)) THEN H=LEN(L1$(J))\n375 GOTO 105\n380 '-----------------------------------------------------------K COMMAND\n385 H=1:I2=J:I3=M1(J,0):FOR J1=1 TO T\n390 IF M1(J,1)=-1 THEN GOTO 410\n395 I4=M1(J,1):L1$(J)=\"\":M1(I4,0)=I3\n400 M1(IN,0)=J:M1(J,0)=0:M1(J,1)=IN:IN=J\n405 J=I4:NEXT\n410 IF I2=LN THEN LN=J ELSE M1(I3,1)=J\n415 GOTO 105\n420 '-----------------------------------------------------------L COMMAND\n425 I2=J:FOR J1=1 TO T\n430 PRINT L1$(I2):IF M1(I2,1)=-1 THEN GOTO 105 ELSE I2=M1(I2,1):NEXT\n435 GOTO 105\n440 '-----------------------------------------------------------N COMMAND\n445 I2=LN\n450 IF M1(I2,1)=-1 THEN GOTO 465 ELSE PRINT #2,L1$(I2):I2=M1(I2,1)\n455 GOTO 450\n460 '-----------------------------------------------------------R COMMAND\n465 J=1:A#=0:LN=1:I=1:FE=0:GOSUB 470:GOTO 105\n470 IF EOF(1) THEN PRINT \"EOF1\":I=I-1:FE=1:GOTO 495\n475 LINE INPUT #1,L$:IF L$=\"\" THEN GOTO 470\n480 A#=A#+LEN(L$)\n485 L1$(I)=L$:M1(I,0)=I-1:IF I=1 THEN 490 ELSE M1(I-1,1)=I\n490 IF I=50 OR A#>2000 THEN GOTO 495 ELSE I=I+1:GOTO 470\n495 M1(I,1)=I+1:I=I+1:L1$(I)=\"END OF BUFFER\":M1(I,0)=I-1:M1(I,1)=-1:H=1:IN=I+1\n500 FOR I2=IN TO 100:M1(I2,1)=I2+1:M1(I2,0)=I2-1:NEXT\n505 M1(IN,0)=0:M1(I2-1,1)=-1:RETURN\n510 '-----------------------------------------------------------V COMMAND\n515 PRINT LEFT$(L1$(J),H):GOTO 105\n520 '-----------------------------------------------------------X COMMAND\n525 I2=LN\n530 IF M1(I2,1)=-1 THEN GOTO 535 ELSE PRINT #2,L1$(I2):I2=M1(I2,1):GOTO 530\n535 IF FE=0 THEN I=1:A#=0:GOSUB 470 GOTO 525\n540 CLOSE:ON ERROR GOTO 555:LINE INPUT \"BACKUP FILE NAME?\";N3$:KILL N3$\n545 NAME N1$ AS N3$\n550 NAME N2$ AS N1$: CLEAR 200:END\n555 IF ERR = 53 THEN GOTO 545: ELSE:ON ERROR GOTO 0<\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"
      Text Editor Prevents “Starvation” and Programming Hassles By Donald Fitchhorn MITS Computer Notes, October 1977. Why I wrote an editor My main objective in writing an editor was to complement DISK EXTENDED BASIC’s built-in EDIT feature. This feature is invaluable if the location of a needed change is already known. But what about our friend […]<\/p>\n","protected":false},"author":1,"featured_media":81,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[18],"tags":[13,12,17],"class_list":["post-78","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-basic-text-editors","tag-8k-basic","tag-altair-basic","tag-retrocomputing"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/permacomputer.solarpunk.au\/wp-content\/uploads\/2026\/03\/edit-page-01.jpg","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=\/wp\/v2\/posts\/78","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=78"}],"version-history":[{"count":5,"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=\/wp\/v2\/posts\/78\/revisions"}],"predecessor-version":[{"id":105,"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=\/wp\/v2\/posts\/78\/revisions\/105"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=\/wp\/v2\/media\/81"}],"wp:attachment":[{"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=78"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=78"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/permacomputer.solarpunk.au\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=78"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}