How to convert tables from html to graphics. Convert HTML to Microsoft Excel formats. Things to Keep in Mind When Converting Excel Files to HTML

In contact with

Classmates

ALEXEY MICHURIN

Converting from Excel to HTML:

correct, high quality, simple

So, our task is to correctly convert a document from xls format to HTML format, taking into account the formatting of the source document, and at the same time get by with “little blood”

Formulation of the problem. Or what's the problem?

Many webmasters often face the task of converting files Microsoft Excel to other formats. This is often fraught with difficulties, since the xls format, as everyone knows, is not documented.

In some cases, it is possible to save Excel data in documented formats and then process it. But often this method does not work satisfactorily. Simple formats, convenient for processing, are not able to preserve all information about the formatting of the document, and the implementation of a handler for complex formats is unreasonably labor-intensive.

You don't have to look far for an example. Many companies that have their own web pages and update them periodically conduct their business using Excel. Every time information is updated on the server, the webmaster is faced with the task of converting. Moreover, the task can be complicated by the following aspects:

Firstly, this is a design change. Price-list prepared in Excel is usually designed to be printed on a black and white printer. Price-list on the website - no. At least for this reason, a simple “Save as web page” is not suitable (I’m not talking about the quality of the HTML code obtained when saving this way).

Secondly, when converting it is necessary to take into account the specifics of Excel. For example, many people editing price-list make extensive use of the Format/Row/Hide command. In this case, the line height becomes zero, and the line seems to disappear from the screen and on print. It is clear that such lines should not end up on the website. However, they are perfectly saved in other formats and are no different from regular, non-hidden strings. This results in the doctrine of “Save as delimited text and process” not giving satisfactory results.

Thirdly, price-list often uses formatting, the preservation of which is critical. For example, the names of some products may be crossed out or highlighted in color as a sign that these products were and will definitely be, but now they are not. Some items may be italicized and so on. All this information disappears without a trace if you save the price-list in a simple format, say, as tab-delimited text.

So, our task is to correctly convert a document from xls format to HTML format, taking into account the formatting of the source document, and at the same time get by with “little loss.”

I suggest breaking this task into two. The first is saving data in a simple format, which will nevertheless contain all the information we need about the document layout. The second is processing this format and creating an HTML page.

I propose to solve the first task (export) using Excel. Here we actually have no choice; the xls format can only be processed by the only application in the world that understands it. This is dialectics.

I propose to solve the second problem using the Perl language. Why? Because this language is focused on working with strings and solving problems like ours (Perl - Practical Extraction and Report Language - that's what we need). Because quite a lot of programmers involved in web development know this language (if you are not one of them and plan to work on the web, then I sincerely recommend paying attention to Perl). Because this language is free and available to any user on any platform. And because my Perl code can then be easily modified, forcing it, for example, to place each price-list section in a separate file, sort price list items in different ways, track updates and price dynamics, supply each item with HTML form fields for on -line order in a web store... In the end, my script can easily be turned into a CGI application for administering a web server.

This solution seems to me to be the most flexible, functional and compact, because each part of the problem is solved by the tool that is most suitable for solving it.

Let's start with a specific example. As a “guinea pig” I offer the following price list (see Fig. 1).

As you can see, it combines all the unpleasant elements mentioned above: both formatting (background, strikethroughs, bold font) and hidden lines (if you look closely, you will notice that after the ninth line there is a twelfth line). Let's get to it.

Export data from Excel

Let's start solving the first problem. To export data from Excel, I propose a simple macro in Visual Basic (line numbers are given only for ease of commenting):

1: Sub table2table()

2: "

3: "macro that saves the selected fragment of the table

4: " in text format with formatting notes

5: "

6: With ActiveWindow.RangeSelection

7: c1 = .Columns.Column

8: c2 = .Columns.Count - 1 + c1

9: r1 = .Rows.Row

10: r2 = .Rows.Count - 1 + r1

11: End With

12: If (r1 - r2 = 0 And c1 - c2 = 0) Then

13: MsgBox_

14: "something is not allocated enough (for saving) ,-)", _

15: vbCritical, "macro message"

16: End If

17: fileSaveName = Application.GetSaveAsFilename(_

18: InitialFileName:="file", _

19: fileFilter:="Text Files (*.txt), *.txt", _

20: Title:="saving the page in our format")

21: If fileSaveName = False Then

22: MsgBox_

23: "the file was not selected. No action was taken.", _

24: vbCritical, "macro message"

25: Else

28: Open fileSaveName For Output As #1

29: For r = r1 To r2

30: l = CStr(Rows(r).RowHeight)

31: For c = c1 To c2

32: With Cells(r, c)

33: l = l + sep + CStr(.Text) + _

37: End With

38:Next

39: Print #1, l

40:Next

41: Close #1

42: End If

43: End Sub

This macro saves the selected part of the price list to a specified file. The macro can be added to the working version of the price list and made a button to call it (outside the print area), or it can be stored in separate file. Placing it in a document is very simple: call the Visual Basic Editor (menu: “Tools –> Macro –> Visual Basic Editor”; or ), create a new module (menu: “Insert -> Module”) and enter the text given here (without line numbers). Now you can draw a button (a tool in the Forms panel) and assign a macro to it.

Let's take a quick look at how this code works.

The first line is the macro declaration. As you can see, I called it simply table2table, you can call it more sonorously.

In lines 6 to 11 we define the boundaries of the selected part of the document (after all, we will save only the selected part). Now c1 and c2 are the numbers of the first and last column, and r1 and r2 are the first and last rows of the selected area.

Next, in lines 12 to 16, we check whether the area has been selected or whether our macro will only have to work with one cell. This, of course, you don’t have to do, but, most likely, it’s not you who will run this macro, but the managers who edit the price list; you can’t always count on their accuracy. So, if nothing has been selected, our macro will issue a warning (see Fig. 2).

In lines 17 through 20, we call the Application.GetSaveAsFilename dialog so the user can select a file name (see Figure 3).

Again, you can just specify a fixed name, but I find this to be inconvenient even if you are running the macro yourself.

Lines 21 through 42 contain an if-then-else construct that checks whether a file name was specified to save or the user clicked the “Cancel” button of the “Save As...” dialog.

If the user refuses to save, then a corresponding message is displayed (lines 22 to 24); if the file name is specified, then the most interesting part begins - saving the data.

But before we discuss the saving procedure (lines 26 to 41), let's say a few words about exactly what format we intend to save the data in. I propose the easiest format for processing: ASCII text. Each row corresponds to a row in the table being saved. The fields are separated by single character delimiters. The first field is the row height (this information is needed to filter out “hidden” rows). All subsequent fields are the contents of the cells, but each of these fields contains several subfields separated by their own delimiters. Subfields carry various information about the cell: content, formatting options.

Our field and subfield separators are specified by ASCII codes in lines 26 and 27, respectively. You can choose more convenient separators. For example, if you are sure that the “:” character never appears in your data, then you can use it as a separator or subdivider.

Let's organize the loop line by line (line 29).

For each line we calculate the height. At the same time, we begin to prepare a line to be saved to a file in the l variable (line 30 of the listing).

In the loop (line of Listing 31) through the cells of the saved table row, we add to line l all the information we are interested in about the cells, providing it with separators.

What cell properties do we preserve?

First of all, the cell text. Please note that we are using the.Text property, not the.Value property. This is no coincidence. The.Value property returns the true contents of the cell, the.Text property returns the text that is displayed on the monitor and printed. These two values may not (and usually do not) match because the values are displayed according to the specified cell format (for example, numbers are displayed with a specified number of decimal places).

The MergeCells property indicates whether a cell is part of a group of merged cells.

The.Font.Bold property reflects the boldness of the text in the cell.

The.Font.Strikethrough property indicates whether the text was designed as strikethrough.

For our example, we probably don’t need anything else. However, I cannot help but note a number of useful properties that may be useful to you. The names of these properties are quite eloquent, and I will not comment on them, I will limit myself to listing:

.Font.Name
.Font.FontStyle
.Font.Size
.Font.Underline
.Font.ColorIndex
.Font.Italic
.Horizontal Alignment
.Vertical Alignment
.ColorIndex
.Pattern

Note that all properties are explicitly cast to string type by the CStr function (lines 33 to 36). This is a very useful procedure that will forever save you from the headache of type conversions.

An important caveat must be made here. The point is that the CStr function is not able to handle undefined values. If these appear in your documents, then instead of CStr you can use your own function for converting values to text format. For example, safeCStr:

1: Function safeCStr(p As Variant) As String
2: If IsNull(p) Then safeCStr = "" Else safeCStr = CStr(p)
3: End Function

I should note that I myself have never encountered such situations, but the scientific and technical consultant of the magazine easily found a price list on the Internet in which the .Font.Bold property was not defined in some cells. I believe that such documents may arise from exporting data from other applications. For example, 1C products allow data export to Excel. In a word, such a situation is possible. – Author's note.

So, you select the area to save (in our example, these are the first three columns of the table, lines 4 to 21), click the button you created, select a file name, and the file is saved. What to do with it next?

Creating an HTML page from exported data

You can do whatever you want with this file, because its format is completely known to us (it’s nice to know that). I will give an example of generating an HTML page.

As I said, I offer a Perl script:

1: #!/usr/bin/perl -w

3: #use strict;

5: # my ($TRUE, $FALSE)=("True", "False");

6: my ($TRUE, $FALSE)=("True", "False");

8: sub qtnum (

9: my $t=shift;

10: $t=~s|,(\d+)|, $1|;

11: return $t;

12: }

14: sub qtstring (

15: my $t=shift;

16: $t=~s/\&/\&/g;

17: $t=~s/\"/\"/g;

18: $t=~s/\>/\>/g;

19: $t=~s/\

20: return $t;

21: }

23: print<<"TEXT";

24:

25:

26: price list of a certain company

27:

32:

33:

34:

35:

36:

37:

38:

39:

40:

41:

42:

43:

44:

45:

46:

47:

48:

49:

50: TEXT

52: while (<>) {

53: s/[\x0A\x0D]+$//;

54: my @f=split /\x09/;

55: my $lh=shift @f;

56: my ($name, $usd, $rub)=map () @f;

57: if ($lh) (

58: if ($name->eq $TRUE) ( # process section header

59: print "

\n";

62: ) else ( # process regular string

63: print<<"TEXT" .

64:

65: onMouseOver="this.className="al";"

66: onMouseOut="this.className = "";">

\n \n \n";

80: }

81: print<<"TEXT";

82:

83:

84: TEXT

85: ) else (

86: warn "hidden line: ".$name->."\n";

87: }

88: }

90:print<<"TEXT";

91:

price list of a certain company


Name of product	price

	c.u.	rub.

" . 60: $name-> . 61: "
67: TEXT 68: ($name->eq $TRUE?" ~~":"") .~~ ~~69: qtstring($name->) .~~ ~~70: ($name->eq $TRUE?"~~":"") . 71: qq\|	\| . 72: ($usd->eq  $TRUE?" ":"") . 73: qtnum($usd->) . 74: ($usd->eq $TRUE?"":"") . 75:qq\|	\| . 76: ($rub->eq  $TRUE?" ":"") . 77: qtnum($rub->) . 78: ($rub->eq $TRUE?"":"") . 79: "

92:

93:

94: TEXT

The script takes input from a file specified as a command line parameter or from standard input and produces HTML code on standard output. That is, you can run it like this:

perl file2html.pl file.txt >file.html

or, for example, like this:

cat file.txt | perl file2html.pl >file.html

Let's figure out how this script works (I will assume that the reader is somewhat familiar with Perl).

The first line is the standard magic line of any UNIX script. Windows users can ignore it. The third line contains the commented out use strict instruction. It will only be useful to you for debugging.

On lines 5 and 6, we'll define the variables $TRUE and $FALSE, which will hold the true and false values that Excel produces. The fact is that Russian Excel uses Russian words, European Excel uses English ones. Comment out the line that suits you and comment out the extra one.

The qtnum procedure (lines 8 to 12) adds tags to the number entry, turning "3,14" into "3, 14" That is, cents and pennies will be displayed in a smaller font. This is a purely cosmetic measure.

The qtstring procedure (lines 13 to 21) quotas “unsafe” characters: & (and), “ (double quote),< (больше), >(less). This, as you understand, is a mandatory measure.

Lines 23 to 50 print the header of the HTML document.

In the while loop (lines 52 to 88), we read the input file line by line, convert it into an HTML document, and output it to stdout.

In line 53, the end-of-line character(s) is cut off from the next read line. I don't use the standard Perl chop and chomp functions because the file being processed is created under Windows, and the handler (our Perl script) can run under UNIX. The file can be transmitted in very exotic ways. For example, many will probably want to slightly modify my code and turn it into a CGI application for administering their own server. Therefore, I do not rely on standard functions, but explicitly state that I need to remove all \x0A and \x0D characters at the end of the line.

The first field, the line height, is stored in the $lh variable (line 55). All other fields are divided into sub-fields. As a result, the variables $name, $usd, $rub are assigned pointers to arrays containing all the necessary information about the contents and formatting of the corresponding cell. $name – cell with the name of the product, $usd – cell with the price in dollars, $rub – cell with the price in rubles. This is done with one single line 56.

If the line height is not zero, then we execute the block from lines 58 to 84. Otherwise, we issue a warning to stderr that a hidden line was detected and ignored (line 86).

Processing table rows may seem complicated at first glance.

First of all, we find out what we are dealing with: on line 58, we check the truth of the .MergeCells property of the cell with the product name. If this cell is merged, then it is a section header, then the code that generates the header is executed (lines 59 to 61).

If it turns out that we are dealing with a regular string, then the else block is executed (lines 63 to 79). Here a row of the HTML table is formed into which additional formatting elements are inserted (for those table rows where this is necessary).

Please note that we have built a basic DHTML trick into our document. In the table, the row on which the mouse pointer is located is always highlighted. This makes the table easier to read. Agree that it is difficult to achieve such an effect using Excel (by saving the document as a web page).

In lines 90–94 we print the end tags of the document. Please note that there must be an empty line at the end of the program file. Otherwise, the last word ("TEXT") (line 94) will not be parsed correctly by the Perl interpreter.

See the picture (page 82) for the output.

Agree, there was something to fight for!

BUGS. What else can you add?

I have no doubt that although my examples are fully functional, few people will use them without the slightest modification. I would like to throw in a couple of thoughts about what can be improved in these scripts, so that when modifying them you do not do unnecessary work, but kill as many birds with one stone as possible.

Scripted in Visual Basic

Here you will most likely have to change the set of saved cell parameters. I provide a list of the most useful ones in the discussion of this scenario. If you need something exotic, refer to the Microsoft documentation, properties of the Range object.

Probably, many will consider it a flaw that the macro unconditionally replaces existing files (if you specify an existing file to save). This, as you understand, is easy to fix.

Probably, for real documents it will not be difficult to formulate the conditions under which the macro itself will determine the area of the price list (or other document) to be saved. Then this process can be automated. My solution (saving the selected area) is more universal than convenient.

Finally, the reader may rightly ask why a macro for Excel saves hidden rows, since they can be eliminated already at the export stage? I take my hat off to the reader's attentiveness (secretly hoping for a reciprocal gesture towards my insight). It's really not necessary to save hidden rows, I'm just used to saving everything. Causes? Perhaps hidden lines will still be needed. Or you might want to know exactly which lines were ignored (my Perl script, as you remember, reports every hidden line). Additionally, line height information can be a criterion for identifying headers... Although, of course, you can slightly modify the VB code and not save hidden lines.

Perl script

Of course, you will most likely change the entire HTML code (which is most of the script) significantly. Of course, you will have to change the number of columns, the header, many will remove my empty separator lines from the HTML code, add nested tables, change DHTML functions, add CSS tables... But this is not the most important or fundamental change.

Most likely, you will have to “teach” this script to break large documents into sections and save these sections in different files, because the price list of a very average company in HTML format can be hundreds of kilobytes. Not every web browser will wait until the end of downloading such a document. You may want to add sorting (if the items in the printed price list and the web price list need to be in a different order).

Undoubtedly, the function of comparing the current price list with the previous one will be useful, which will add information about updates and price dynamics.

I would advise organizing such procedures (not directly related to HTML layout) in the form of separate programs or modules. By the way, part of the work on HTML layout can be entrusted to the SSI mechanism, and let the script collect the SHTML document. A set of simple tools is always more convenient, flexible and manageable than one universal one. Stay away from the rake where the creators of the microwave phone and the toothbrush TV walk.

The list of tips and suggestions can be continued endlessly, but I think I have already awakened your imagination, and you can cope further without me. Adapting the example given here to your specific conditions may require several hours of work. But then you will be generously rewarded, because all subsequent updates of information on your web server will be done with just a few touches of the keyboard and mouse!

In contact with

For example, let's take an Excel table consisting of 4 columns and 12 rows.
Column A - numbering of items in ascending order of line items
Column B - number of items
Column C - price of one item
Column D - the sum of the cost of items in one line as the product of the price of the item and their quantity
Column D cell D12 - sum of the cost of all items

It goes without saying that the table itself is in the form excel file cannot be posted in the site materials for many reasons. To place it and publish it in the form of a textual representation of data, you need conversion to HTML compatible format.

First we add before the table one more line, highlighted red frame .
Then before each table column we add one more column, add 4 more columns, highlighted green frames .

As a result, we get a table consisting of 8 columns and 13 rows.

To cell A1 write as text HTML table tag

To range cells A2-A11 before each cell in a column B we write down the opening ones as text HTML row and cell tags
To cell I14 write the closing text as text HTML table tag

To range cells C2-C11 , E2-E11 , G2-G11 before each column cell D , F And H write the closing and opening as text HTML cell tags

To range cells I2-I13 after each cell of the column H write the closing ones as text HTML cell and row tags

Next to cells A12 And A13 write down the opening as text HTML line tag and opening HTML cell tag with attribute colspan combining in lines 12 And 13 columns B , D And F in one cell

As a result, we get a table filled with both initial data in excel format and HTML tags in the form of text.

Next in Excel editor, select the table in the range A1-I13, in the program menu select the command "Save as" and save the selected fragment as a text file (for example - tabltxt.txt), the encoding does not matter, you can save it as encoded UTF-8 and in encoding Ms-DOS. Excel will display a warning window:

Press the key "OK" and Excel will again display a warning window:

Press the key "YES" and the selected fragment will be saved as a text file tabltxt.txt

Next, we transfer further work on conversion to an HTML editor; in principle, everything else can also be done in a simple text editor, but the option is with an HTML editor more preferable.

Open the file tabltxt.txt in any text editor, select all contents as text and paste into HTML editor in HTML mode. Let's get the following source HTML text of the table. You can also select a saved file from Excel. The only difference will be that depending on the encoding of the saved file, it may contain "artifacts" in the form of extra characters as can be seen in the screenshot in the cells ( " " ).

Next we delete everything "artifacts" if present, and all spaces. We also write a CSS style for table cells: td (padding: 1px 12px; text-align: center;) As a result, we get the original HTML text of the table in HTML format. (the screenshot is shown as is without structural HTML formatting as it would look in a text editor). In this form, the source text of the table is suitable for use as an HTML data table for publication in the material, since it is a purely HTML format.

After saving the table as an HTML file and viewing it in the Browser, we will get the following display of the table converted from Excel format to HTML format.

The meaning of all the above actions comes down to one thing:

1 . Before each row of the excel table, create an HTML line and the beginning of an HTML cell.
2 . Form HTML cells between the columns of an excel table, the end of one and the beginning of another.
3 . Form after each row of the excel table, ending HTML cells and rows.
4 . Form the beginning and end of the excel table, the beginning and end of the HTML table as a table tag.

It goes without saying that for a more presentable display of table data, it is necessary to write CSS classes in the HTML tags of the table rows and cells. For example, with attributes of indents, font color and style, borders and other design. But this is a separate topic not discussed in this material.....

If you've created a nice spreadsheet in Excel and now want to publish it as a web page, the easiest way to do this is to export it to a good old HTML file. In this article, we will look at several ways to convert data from Excel to HTML, determine the pros and cons of each method, and work with you to complete this conversion step by step.

Convert Excel Spreadsheets to HTML Using the Save As Web Page Tool

Let's say you've created a rich report in Excel and now want to export all this information, along with a chart and a pivot table, to your company website so that your colleagues can see it online through web browsers without having to open Excel.

To convert Excel data to HTML, follow these steps. These instructions apply to Excel 2013, 2010, and 2007.

Advice: If this is your first time converting an Excel workbook to an HTML file, it may be wise to first save the web page to your hard drive so that you can make edits if necessary before publishing the page online or on your local network.

Comment: The HTML code generated by Excel is not very clean! It will be great when, having converted a large table with a complex design, you open it in any HTML editor and clean up the code before publishing. As a result, the page on the site will load noticeably faster.

5 Things to Remember When Converting Excel Files to HTML

When using the Save As Web Page tool, it is important to understand how its main options work so you don't make the most common mistakes and avoid the most common error messages. In this section, you will find a brief overview of the options that you need to pay special attention to when converting Excel files to HTML.

1. Supporting files and hyperlinks

As you know, web pages often contain pictures and other supporting files, as well as hyperlinks to other websites. By converting an Excel file into a web page, the application automatically collects related files and hyperlinks for you and saves them in a supporting folder.

When you save supporting files, such as charts and background textures, to the same Web server, Excel creates all the links relative. A relative link (URL) points to a file within the same website; it specifies the file name or root folder instead of the full site name (for example, href=”/images/001.png”). When you delete any item saved as a relative link, Microsoft Excel automatically deletes the associated file from the supporting folder.

So, the main rule is Always save the web page and supporting files in one place, otherwise the web page will not display correctly. If you move or copy your web page to another location, make sure that the supporting folder is copied to the same location, otherwise the links will not be correct. If you resave the web page to another location, Microsoft Excel will copy the supporting folder automatically.

If you save web pages to different locations or if the Excel file contains hyperlinks to external websites, then in such cases absolute links. Absolute links contain the full path to a file or web page, which can be accessed from anywhere, for example: www.your-domain/section/page.htm.

2. Making changes and resaving the web page

In theory, you could save an Excel workbook as a web page, then open the resulting web page in Excel, make changes, and resave the file. However, in this case, some Excel features will not be available. For example, any charts contained in your workbook will turn into independent drawings, and you will not be able to edit them in Excel as you could previously.

Therefore, the best way is to first update the original Excel workbook with some changes, then save it as an Excel workbook (.xlsx), and only then convert it back to a web page.

3. Auto-republish a web page

If you have checked the box next to the option AutoRepublish(Auto-Republish) in the dialog box Publish As Web Page(Publish a Web Page) which we mentioned earlier in this article, then your web page will be automatically updated every time you save a workbook. This feature is very useful and allows you to always keep an online copy of your Excel spreadsheet up to date.

If you enable the option AutoRepublish(Auto-Republish), each time you save a workbook, a message will appear asking you to confirm whether you want to enable or disable Auto-Republish. If you want the Excel sheet to be automatically published, then select Enable…(Enable...) and click OK.

However, there may be circumstances when you do not want to automatically publish an Excel worksheet or its elements, for example, if the file contains confidential information or was modified by someone who is not a trusted person. In this case, you can temporarily or permanently disable auto-republishing.

To temporarily disable auto-republishing, select the first option given in the above post – Disable the AutoRepublish feature while this workbook is open(Disable Auto-Republish feature when this book is open.) This will disable automatic publishing for the current Excel session, but will enable it again the next time you open the workbook.

To turn off auto-republish permanently for all selected items, open your Excel workbook, go to the dialog box Publish As Web Page(Publish Web Page) and click the button Publish(Publish). In chapter Items to publish(Published items) in the list Choose(Select) select the item you do not want to publish and click the button Remove(Delete).

4. Excel features that are not supported on web pages

Unfortunately, some very useful and popular Excel features become unavailable when you convert your Excel sheets to HTML:

Uword formatting not supported when saving Excel sheet as Single File Web Page(Web page in this file) so make sure you save it as Web Page(Webpage). Histograms, color scales, and icon sets are not supported by both web page formats.
Rotated or vevertical text is not supported when exporting data from Excel to a web page format. Any rotated or vertical text in your workbook will be converted to horizontal text.

5. The most common difficulties encountered when converting Excel files to HTML

When converting an Excel workbook to a web page, you may encounter the following known difficulties.

Sometimes a manager comes and says: “I want to see this table on the website.”
And he leaves.
Two standard paths emerge:
- either through some admin panel in the editor, create a table and fill it with values;
- or manually directly into the html and also fill it with values.
And it’s okay if there are 3x5 cells, and if there are more.

Having encountered a similar problem several years ago, I discovered a method based on using Windows Live Writer (software for writing and sending posts to some blogging platforms).

It's simple. We paste the copied table into WLW using a special paste, preserving the format.

Then go to the bottom “Source” tab in WLW and copy all the huge code from the field

It turns out the same or almost the same as in the original. It takes seconds, not counting the one-time costs of attaching WLW to some blog account.
Example here codepen

As a result, we get a single page with 320 lines of text.

There you still need to find what you need to use...

Having encountered something similar several years ago, I discovered a method based on using Windows Live Writer (software for writing and sending posts to some blogging platforms).

It's simple. We paste the copied table into WLW using a special paste, preserving the format.

Then go to the bottom “Source” tab in WLW and copy all the huge code from the field

It turns out the same or almost the same as in the original. It takes seconds, not counting the one-time costs of attaching WLW to some blog account.
Example here codepen

As a result, we get a single page with 320 lines of text.

There you still need to find what you need to use...