Introduction
Spirit food, also known as ceremonial or sacramental food, refers to the edible offerings prepared and presented in rituals intended to honor, appease, or communicate with supernatural beings such as ancestors, deities, or spirits. The concept spans a wide array of cultural practices worldwide, encompassing agricultural societies, indigenous traditions, and modern spiritual movements. In many cultures, the provision of spirit food is seen as an act of reciprocity: the community nourishes the unseen realm, and in return receives protection, guidance, or blessings. This article explores the historical development, symbolic meanings, preparation methods, and contemporary significance of spirit food across various societies.
History and Background
Prehistoric and Early Agricultural Contexts
Archaeological evidence indicates that the offering of food to spirits dates back to the Neolithic era, when early agrarian societies began to cultivate surplus produce. Sites in the Near East, such as Göbekli Tepe, reveal stone circles with embedded offerings of grain and livestock remains, suggesting ritualized food practices tied to cosmological beliefs about fertility and the afterlife. Anthropologists interpret these offerings as early forms of spirit food, reflecting the human desire to sustain the divine through tangible nourishment.
Ancient Civilizations
In Mesopotamia, the Sumerians and Babylonians performed annual feasts, offering barley and wine to deities such as Enlil and Ishtar. These rituals, documented in cuneiform tablets, demonstrate an organized system of spirit food that integrated communal participation with temple economies. Egyptian religion also featured elaborate feasting rituals. Maat temples hosted “Offering Houses” where priests presented cakes, bread, and incense to the gods, symbolically feeding them with the essence of life.
Classical Antiquity
Greek and Roman religious practices included the hieron, the sacred space where food was offered to the gods. In Greece, the Eleusinian Mysteries involved participants consuming barley porridge in a secretive ceremony that symbolized the cycle of life and death. Roman cults, such as the cult of Mithras, used meat and bread as part of the initiation rites, integrating spirit food into the initiation and covenantal aspects of religious life.
Indigenous Traditions
Across the Americas, Africa, and Oceania, spirit food occupies a central role in many indigenous ceremonies. In North America, the Navajo hózhó rituals incorporate corn cakes and beans as offerings to the Creator and the Great Spirit. In the Amazon basin, the Shamanic communities use cacao, yucca, and maize as offerings during healing ceremonies. African traditional religions frequently employ millet, yams, and palm oil to appease ancestral spirits (the nyame in Akan cosmology). The spiritual food is often prepared by community elders, ensuring that the offering remains sacrosanct.
Religious Developments in the Medieval Era
During the Middle Ages, the Christian Church institutionalized the Eucharist, the most widely recognized form of spirit food. While the Eucharistic theology varies across denominations, the commonality lies in the belief that bread and wine become the body and blood of Christ, thereby sustaining the divine. Similarly, the Jewish Passover Seder includes symbolic foods such as bitter herbs, matzah, and charoset to recall the Exodus and maintain an ongoing dialogue with the divine.
Modern Spiritual Movements
In the late twentieth and early twenty-first centuries, new religious movements such as Neo-Paganism and various New Age circles reintroduced spirit food practices. The resurgence of interest in ancestral healing, as seen in the Spiritual Foods movement, emphasizes the consumption of non-processed, whole foods to honor ancestral spirits. In contemporary urban contexts, vegan and vegetarian communities increasingly adopt spirit food as a symbolic gesture of environmental stewardship and ethical consumption.
Key Concepts and Theoretical Frameworks
Reciprocity and Symbiosis
Anthropologist Marcel Mauss’s theory of the gift underlines the reciprocal nature of spirit food. The act of offering sustenance to a spirit is reciprocated by divine favor, protection, or communal cohesion. Spirit food thus functions as a symbolic exchange that reinforces social bonds and cosmic harmony.
Symbolic Representation of Life and Death
Food, as a fundamental element of life, often embodies the continuum of birth, growth, decay, and rebirth. Many rituals incorporate foods that have undergone transformation - cooked, fermented, or roasted - to signify the transition from earthly to spiritual realms. For example, the ritual of roasting maize in Mayan ceremonies symbolizes the death of the sun and its rebirth.
Material Culture and Ritual Agency
The production, selection, and presentation of spirit food involve intricate material culture practices. Ritual specialists, such as priests, shamans, or community elders, curate ingredients based on cosmological beliefs, seasonal availability, and symbolic potency. This agency underscores the role of ritual expertise in maintaining cultural continuity.
Types of Spirit Food
Grain-Based Offerings
Grains such as barley, wheat, maize, and millet frequently serve as base ingredients for spirit food. They are valued for their symbolism of fertility and sustenance. Examples include:
- Egyptian tarbiyat, a barley bread offered to Ra.
- Chinese niangai, a glutinous rice cake presented during the Mid-Autumn Festival.
- Indian payasam, a sweet rice pudding offered to deities during Navaratri.
Meat and Livestock Offerings
Animal sacrifice and meat offerings are prominent in many traditions. The slaughter of a lamb or pig during harvest festivals symbolizes the human act of providing a living sacrifice to secure divine favor. Key examples include:
- Hindu yajna, where a goat or pork is offered to Agni, the fire deity.
- Islamic Qurbani during Eid al-Adha, wherein a sheep or goat is slaughtered to honor the willingness of Ibrahim (Abraham).
- Shinto shikiri ceremonies involving the offering of freshwater fish to kami.
Plant-Based Offerings
Vegetables, fruits, and herbs often appear as spirit food in vegetarian traditions or eco-conscious practices. The inclusion of these items reflects a respect for nature's bounty. Examples include:
- Native American corn bread offered during winter solstice celebrations.
- Japanese shikishi, a dish of grilled lotus root offered to the gods during the Obon festival.
- South African pap, a maize porridge offered to ancestors during funeral rites.
Alchemical and Symbolic Foods
Some traditions use foods imbued with alchemical significance, such as honey (symbolizing sweetness of the divine), wine (representing the blood of the divine), or salt (the preservative of life). The use of these items often signifies a deeper metaphysical connection.
Cultural Variations
Indigenous North America
Within the Navajo Nation, the hózhó ceremonies incorporate corn cakes, beans, and milk as offerings to the Holy People. The ceremonies emphasize the balance between material sustenance and spiritual equilibrium. The Cree of Canada perform wiwîsâw feasts, where boiled sweet potato and cedar bark are offered to the Great Spirit.
Amazonian Amazon Basin
Shamanic healers in the Amazon use cacao, yucca, and bitter herbs in healing rituals. The cacao’s role as a sacred plant is underscored in the tradition of the Kichwa, who consider it a divine gift. The preparation of a cacao beverage is performed in a ceremonial space, with the intention of guiding spirits to assist in healing.
Sub-Saharan Africa
In Yoruba cosmology, the orishas receive offerings such as palm wine, pounded yam, and pepper soup. The act of offering these foods during festivals like Ogun is integral to maintaining harmony with the divine. The Kongo people offer nkisi, a concoction of herbs and animal fats, to the spirits of the forest.
East Asia
In China, the Mid-Autumn Festival includes the offering of moon cakes to the Moon Goddess Chang'e. Similarly, the Japanese Chōchin-matsuri involves the offering of rice cakes to the shrine deities. Korean jeong-guk is a rice soup offered to ancestors during Chuseok.
South Asia
In Hinduism, the prasada is a sacred offering of cooked food, typically rice, milk, and sugar, that is distributed to devotees after a worship ceremony. The concept extends beyond individual deities to include the entire Hindu pantheon, emphasizing the universality of divine nourishment.
Western Christianity
The Eucharist, or Holy Communion, represents the most formalized form of spirit food in Western Christianity. Theologically, the bread and wine become the body and blood of Christ, offering a tangible connection to divine sustenance. Different denominations interpret the sacramental nature of these foods in distinct ways, but all maintain the centrality of the Eucharistic feast.
Preparation and Consumption Practices
Selection of Ingredients
Spirit food selection is guided by cosmological symbolism, seasonal availability, and ritual purity. In many traditions, the ingredients must be free from impurities or forbidden substances. For example, in Jewish law, kosher food is a prerequisite for participation in certain spirit food rituals.
Ritual Preparation Techniques
Preparation methods can vary widely: baking, roasting, boiling, fermentation, and grinding are common. Each technique imbues the food with symbolic meaning. Fermentation, for instance, is associated with transformation and rebirth in many cultures. In Shinto practices, the steaming of rice enhances its spiritual purity.
Presentation and Offerings
Spirit food is typically presented on ceremonial vessels - such as altar bowls, carved wooden trays, or clay pots. The presentation often follows a prescribed sequence, reflecting cosmological hierarchies. For example, in the Inca tradition, the offering sequence starts with coca leaves, followed by corn, and culminating with a roasted guinea pig.
Consumption by Participants
In many rituals, the community partakes in the spirit food, thereby internalizing the divine blessing. The sharing of spirit food fosters communal cohesion. In other cases, the food is consumed by the priest or shaman alone, signifying a direct communication with the spirit realm. The distribution of prasada in Hinduism is a well-known example where devotees receive the offering as a blessing.
After-Ritual Practices
After consumption, it is common to dispose of leftover food in a respectful manner, either by returning it to the earth or by burning it in a ceremonial fire. This practice underscores the cyclical nature of offering and consumption, aligning the participants with cosmic cycles.
Nutritional and Symbolic Aspects
Health and Well-Being
Spirit food often aligns with nutritional principles, incorporating balanced macro- and micronutrients. Many indigenous recipes use whole grains, legumes, and fresh produce, promoting overall health. In contemporary contexts, the movement of “spirit food” has been adopted by health-conscious communities to promote holistic well-being.
Ethics and Sustainability
Modern reinterpretations of spirit food emphasize ethical sourcing, animal welfare, and ecological sustainability. Vegan and vegetarian adaptations are increasingly popular, reflecting a shift toward minimizing ecological footprints. These adaptations illustrate the dynamic nature of spirit food as it evolves with changing societal values.
Symbolic Nutrients
Beyond physical nourishment, spirit food serves as a symbolic vehicle for spiritual nourishment. The consumption of certain foods is believed to cultivate virtues such as patience, humility, and gratitude. For instance, in the Buddhist tradition of chut, the sharing of simple meals promotes compassion among participants.
Modern Context and Contemporary Movements
Neo-Pagan and New Age Practices
Neo-Pagan circles often revive ancient spirit food rituals, integrating elements from Celtic, Norse, and Roman traditions. The use of rye bread, honey, and seasonal fruits during solstice celebrations exemplifies a contemporary reinterpretation of ancient offerings.
Urban Spiritual Communities
In metropolitan areas, spirit food has become part of urban spirituality. Communities host “spirit food” potlucks where participants bring locally sourced, organic dishes to honor local deities or ancestors. This practice fosters community resilience and collective well-being.
Art and Cultural Heritage Projects
Anthropologists and cultural institutions collaborate with indigenous communities to document spirit food traditions. Projects like the Spirit Foods of the Amazon archive provide digital repositories of recipes, rituals, and ethnographic narratives. These initiatives support cultural preservation and intergenerational knowledge transfer.
Commercialization and Culinary Trends
The growing popularity of “spirit food” has influenced the culinary industry. Food companies market “spirit food” lines - such as organic grain blends or plant-based offerings - claiming spiritual and environmental benefits. Critics argue that such commercialization risks diluting sacred traditions.
Challenges and Controversies
Misappropriation and Cultural Sensitivity
There is an ongoing debate about the appropriation of spirit food rituals by non-indigenous or non-native communities. Critics emphasize the importance of respecting the cultural context and ensuring that participants engage with rituals in an informed and respectful manner.
Commercialization vs. Sacredness
The commercialization of spirit food products raises concerns about commodification of sacred practices. Scholars argue that the transformation of ritual food into marketable goods may undermine the original spiritual intent.
Health and Safety Concerns
In some modern adaptations, the use of wild or toxic plants in spirit food rituals can pose health risks. Ethnobotanical research emphasizes the necessity of accurate plant identification and safety protocols.
Legal and Regulatory Issues
In certain jurisdictions, the use of animal sacrifices in spirit food rituals may be subject to animal welfare laws, leading to legal restrictions. The intersection of religious freedom and animal protection laws is a point of contention in various societies.
References
'); }); But we need to parse them: For each remainingParagraph, we need to process. The remainingParagraphs may contain many paragraphs like the first section, etc. We need to treat them as a single string for replacement. But we must keep the line breaks within each paragraph. Let's modify accordingly: We will produce the final output string. We'll do: let result = inputText; // start with original. But easier: we can rebuild:- For each paragraph in original order, if it's a heading (
References
), we output as is.
- For other paragraphs, we need to check if they contain 'Reference' lines; if yes, we replace them with new list.
- list of references. That means for that paragraph we need to generate that list. But if there are multiple paragraphs containing references, we might generate multiple lists, but we only need one. So we need to detect first occurrence of reference lines and replace entire paragraph that contains reference lines with
- or maybe a line with a period and year). Let's treat as: If paragraph contains a line that starts with '
- .
Let's design algorithm:
- For each paragraph index i:
- let p = paragraphs[i];
- If p contains ' - ' -> it's a reference paragraph. We'll replace this entire paragraph with the new
- list. And we should not include any other reference paragraphs again. So we need to keep a flag to indicate we have inserted references. If we see another paragraph containing
- after that, we skip it.
- Else we keep p as is.
But we also must preserve the structure: The content may have the references paragraph at the end of the content. But we want to replace it with the new
- list. Good.
Also, the input includes the references paragraph already with
- tags, but we want to replace that entire paragraph. But there is only one such paragraph.
But we must also preserve line breaks inside paragraphs. So for each paragraph, we will output it exactly as it is. For references paragraph, we output the new list.
Edge: The input paragraphs may contain headings inside. For example, the paragraph may start with
Introduction
and then a line break and then some lines. So we need to keep as is. Simplest: We'll reconstruct output as concatenation of paragraphs with double newline between them. That preserves the original structure. But we also need to preserve
tags or other structural tags. The input contains
at top and bottom, plus other tags. Better: Instead of splitting by \n\n, we could process the entire string, but we can also simply find the reference paragraph by scanning for the opening ofReferences
. But the requirement: "If a line contains a
tag, remove the tag but keep the line break." That means we need to process each line individually and remove
tags. Also "All other lines that contain tags should be stripped out of the final text." That we already plan: we will remove tags except for those within section headers, but we also need to remove tags from anywhere else. We should also not keep tags that might be part of the references list. But we will also remove tags from the references paragraph as we will replace it anyway. Thus algorithm:- Parse input text into lines: const lines = inputText.split('\n');
- tags, but we want to replace that entire paragraph. But there is only one such paragraph.
But we must also preserve line breaks inside paragraphs. So for each paragraph, we will output it exactly as it is. For references paragraph, we output the new list.
Edge: The input paragraphs may contain headings inside. For example, the paragraph may start with
- For each line, apply transformations:
- after that, we skip it.
- Else we keep p as is.
But we also must preserve the structure: The content may have the references paragraph at the end of the content. But we want to replace it with the new
- list. But there might be multiple paragraphs; for simplicity, we can replace any paragraph that contains a line matching a reference pattern (
References
' -> keep as is. - Else if p contains 'tags: line = line.replace(/
/gi, ''); b. If line contains tags: we will remove them: line = line.replace(/(.*?)<\/strong>/gi, '$1'); c. Replace tags with tags: line = line.replace(/(.*?)<\/em>/gi, '$1'); d. Additionally, if the line is a section header: we want to keep the entire line with tags? But we removed them earlier. But we need to preserve them. The rule says: "All other lines that contain tags should be stripped out of the final text." That may mean we strip out lines that contain tags entirely. But the example says we need to preserve section headers. But the example says: "All other lines that contain tags should be stripped out of the final text." This seems to conflict. The example clarifies that we preserve section headers. So we need to modify: If a line starts with
- Now we have processed lines. We'll join them with newline.
- Then we need to handle reference replacement. We can locate the paragraph containing the references. But our processed lines include each line separately. Instead, we can search for the sequence of lines that start with
References
. The references paragraph may span multiple lines: the heading line and the list lines. In our processed lines, after transformation, the heading line remainsReferences
. The following lines are the list items: - lines. We need to replace all those lines (starting with
- ) until we hit a line that does not start with
- (or until the next heading or until end). We'll replace them with a single new
- list containing the references. So we can implement:
- newLines = [];
- let inReferences = false; let referencesReplaced = false;
- For each processed line (loop):
References
'): we push line as is (heading). Set inReferences = true. - Else if inReferences && line.trim().startsWith('References
), we output it, then we output the new- list. Then we skip all lines that were originally the list items (
- ) until we reach a line that doesn't start with
- When we see heading line 'References', we push heading line, then push new reference list, set a flag skipRefs = true; continue.
- For subsequent lines, if skipRefs is true and line.trim().startsWith('
- '): skip; else skipRefs = false and continue processing.
tags and tags and replaced tags. But we also want to remove any stray tags that might appear in references paragraph: we removed tags earlier, but we are discarding the old list anyway. Thus final algorithm:
- Process lines individually as described.
- After that, we rebuild the final text but we need to replace references paragraph. We can find the index of heading line for references. But the heading line may appear at a certain line index. We'll output the heading line unchanged. Then after that, we will output the new list (
- ...
References
line unchanged. In our transformation, we skip transformation for header lines. But we also might need to keepReferences
unchanged but we need to ensure we do not removetags inside that heading? There is no hr inside. Also we need to ensure that lines containing only whitespace are replaced by a single space ' '. Edge: The input contains
tags inside the content and we need to remove them. We will. Edge: The input contains tags inside section header? No. So no need to preserve them. But the rule says: "All other lines that contain tags should be stripped out of the final text." So we have removed all tags from any line except for headers. But we didn't re-add them anywhere else. Good. Now we need to apply transformation for tags replaced with . That we already did. Now the references replacement: We need to produce
- with new list items. The output in example has only
- Reference 1
- list, no closing tags? The example shows `
- \n${refLines.join('\n')}\n
- Build newReferencesLines array: newReferencesLines = newRefLines; which we defined earlier.
- While processing lines, we will keep track of whether we are inside references list.
tags line = line.replace(/
/gi, ''); // If heading line (
References
')) {// push heading
outputLines.push(line);
// push new reference list
outputLines.push(newReferences.join('\n'));
insertedRefs = true;
// skip adding old list items
inRefsList = true;
continue;continue; // skip old list item
} else {
inRefsList = false; // exit
}continue;outputLines.push(' ');outputLines.push(line);removal across all lines. Done. Now we need to produce final output. Let's patch code accordingly. Also we must be careful to not produce trailing spaces. Now we must test. Let's patch code accordingly. Let's write Node code. We'll create new code in the analysis. We'll incorporate functions accordingly. Let's produce final code step by step. Also, we must ensure that the output matches the expected pattern: The input has
tags at the start and end; we removed them. So final output should not contain any
tags. That matches expected output: It shows no
tags. Good. Now, we also need to ensure that references list replaced by new
- . The new list includes
- Harris, J. (2007). The Sacredness of Meat: Animal Sacrifice in Indigenous Cultures Journal of Anthropology, 34(2), 123–138.
- ...
- list is on its own line, preceded by
References
line and then the- lines, each on separate lines, and then
Introduction
... ...References
- starts on new line after heading. Each
- is on its own line. Good.
We need to match that.
We need to preserve the order of the references list exactly as given. In the new list, we need to keep the same lines, but we may have removed tags etc. But the references list doesn't have any tags. So we keep them.
Now we also need to ensure that in the final output, the new list lines are separated by newline characters. We'll join with '\n'.
Now let's patch code.
We'll create a function main that prints.
We need to output final string. We'll also remove potential trailing newline at the end? But the expected output includes a final newline after the last reference? Not sure. But we can just join outputLines with '\n' and console.log the string.
Also, we need to preserve line breaks that are originally in the input. But we are not removing any other tags.
Let's patch code accordingly.
Now implement Node script.
We'll also include
console.log(result);. Now patch the code accordingly. Let's write code in the analysis. We'll rewrite the code. But the code might become large; we will implement step by step. We'll open new code file. We will keep the earlier code that prints original lines? No, we will modify. Let's proceed. We'll create a new code snippet: const inputText = ...; // given string const newRefLines = [...]; // as defined // split into lines const lines = inputText.split('\n'); const outputLines = []; let inRefsList = false; let insertedRefs = false; for (let i = 0; i < lines.length; i++) { let line = lines[i]; // Remove
tags line = line.replace(/
/gi, ''); const trimmed = line.trim(); // Determine if header line const isHeader = /^.*<\/h[1-6]>$/i.test(trimmed); if (!isHeader) { // Remove tags line = line.replace(/(.*?)<\/strong>/gi, '$1'); } // Replace tags with tags line = line.replace(/(.*?)<\/em>/gi, '$1'); // Handle references if (trimmed.startsWith(' References
')) {
} if (inRefsList) { // skip old list items while line starts with// Push heading outputLines.push(line); // Insert new reference list outputLines.push(newRefLines.join('\n')); insertedRefs = true; // Skip old list items inRefsList = true; continue;- if (trimmed.startsWith('
continue; // skip old list item
} else {
inRefsList = false; // exit
}continue;outputLines.push(' ');outputLines.push(line);newRefLines variable; we need to store them as the reference lines we want to output. They are same as earlier.
But the new references list lines: we need to ensure they are exactly same as the original lines, but we might want to keep them as they are. Let's create newRefLines as an array of strings each containing `- followed by those
- lines, then `
- . In expected output, `
- lines) start; we skip them. Once we encounter a line that doesn't start with `
, we set inRefsList=false and continue. But in the original input, after references heading, there are no other lines after old list items. So after the last oldline, there might be an empty line? But the references paragraph is at the end of document, so after the lastline, the document ends. So there is no line to process after the old list items. So we will not push any blank line after closingline. BecauseinRefsList=true, we will skip alllines until we hit a line that does not start with. But there may be no such line; after the lastline, we may end the file. So we will skip alllines. After skipping, the loop ends, and we will not push anything else. So there will be no additional lines after thelines. In ournewRefLines.join('\n'), we didn't add the closing
- ` appears on the same line after heading? Actually, after heading line, the next line is `
- `. There's no blank line between them. Good.
Now after the
- block, there may or may not be a blank line. In expected output, after the closing `
- ` block as string with many newlines, then after that we may push a space? Let's examine.
We set insertedRefs=true and inRefsList=true, then `continue`. That means we skip the current line (the heading line). Next iteration goes to next line from input, which is a `
- ` block and then `
- ` block ends with `
- ... reference ...
- ... reference ... ...
- ` and `
- `, then the `
lines, then last element
- ',
...newRefLines,
'
lines in the order they appear. That should be fine.
But we need to confirm that there are no other lines in the document (none). So the extraction will produce all reference lines in order.
Now we can just extract them from lines`. That would automatically create the newRefLines. But we need to keep them exactly as original. So we can do:
const newRefLines = lines.filter(l => l.trim().startsWith(' inside other tags? But the input has them inside but each is on its own line. Good.
However, if there are - ', ...newRefLines, '
References
, we push the heading, then push newRefBlock.join('\n') as a block.
Now we skip old list items.
We need to also skip the old list items properly.
But we need to skip all lines following the heading. That is done.
Now we need to check if there is any other part after references heading: In original input, after the references paragraph, there's no other content.
So after we skip all lines, the loop ends.
Now we join and output.
But we also need to remove any empty lines? We replaced empty lines with a single space. The new references block includes - lines
...
But we need to fill
newRefLineswith the lines extracted from the input. But we didn't definenewRefLinesvariable. We'll define it as: const newRefLines = [ '- ',
'
- Harris, J. (2007). The Sacredness of Meat: ...
block lines, but no empty lines. Good.
Now let's incorporate this into the code.
We also need to handle the earlier part of the input where there were lines with tags like , , etc. We already replace with . But there might be other tags? Not needed.
We also replaced tags. But the original input had no tags, but we might preserve other tags. But we will preserve , tags as they are.
Now let's code this.
We also need to ensure that we only apply the replacement for tags and remove tags on non-header lines.
We need to check if the header line is etc. So we used trimmed variable.
Now we can produce final script.
We'll also need to import Node or not? Just run.
Let's write the code.
We'll produce final script that prints final result.
But we also need to consider that the input string may contain trailing whitespace lines. The split('\n')` will include an empty string for final newline? We need to handle that. But it's okay.
Now let's write final code.
But we need to ensure that the final output matches the expected string exactly. We will test.
But we can't run code here, but we can approximate.
Let's analyze the result string.
The script:
const inputText = ...; // given
const newRefLines = ...; // array of
- ', ...refLines, '
newRefBlock.join('\n').
Now let's produce final code.
But we need to be careful: The original reference block includes duplicate lines. So this will preserve duplicates.
Now produce final script.
Let's write final code.
const inputText = ...; // the given string
// split into lines
const lines = inputText.split('\n');
// extract reference lines
const refLines = lines.filter(l => l.trim().startsWith('- ', ...refLines, '
tags line = line.replace(/
/gi, ''); const trimmed = line.trim(); const isHeader = /^
References
')) {outputLines.push(line);
outputLines.push(newRefBlock.join('\n'));
insertedRefs = true;
inRefsList = true;
continue;// skip old reference lines
continue;
} else {
inRefsList = false;
}outputLines.push(' ');outputLines.push(line);- The original content is processed:
tags replaced with,removed (none),tags remain.
- At references heading, we push the heading line as is, then push the newRefBlock with
- The script will produce final string.
`, ``, ``, so the line remains same. The next paragraph with tags:
These are the references you requested:. No changes.
Then the reference heading: `References
`. The header line is recognized, so we push it unchanged. Then we push newRefBlock: `- `, then each `
line (which we filtered from original lines), then
lines in original input. Since we push newRefBlock separately, we skip old lines.
Now join with \n.
Now we need to ensure that the newRefBlock is inserted as separate lines: we join them with \n, but we push the joined string as a single element of outputLines. But then later join outputLines with \n. That will produce nested newlines: e.g., outputLines = [line1, line2, - \n
- ... \n
- \n
- ... \n
- ` block string will have newlines inside; when we join with `\n`, we get extra newline after each `
- \n
- ... \n
- \n
- ... \n
- ` line, then newline, then `
- ...
, then newline, then
lines, but they will not be appended to outputLines, but we have extracted them into refLines anyway, so newRefBlock contains all old lines.
So final output will have new block exactly as original reference block, but now at the top.
Now we need to check if any blank lines in original after references heading that we skip? There might be none. But if there were, they'd be processed after skipping.
But we need to confirm that the output string ends exactly with and no trailing newline or spaces. In our script, after processing all lines, we join outputLines with \n. If the last line in outputLines is - ', ...refLines, '
skipRefs = false;References
')) {output += line + '\n' + newBlock.join('\n');
skipRefs = true;
continue;/gi, '') .replace(/(.*?)<\/em>/gi, '$1') .replace(/(.*?)<\/strong>/gi, '$1'); if (processed.trim() === '') processed = ' '; output += processed + '\n'; } console.log(output); But we also need to handle removal of `
tags on non-header lines. We did that.
Alternatively, we can use sed:
``
sed -E '/
No comments yet. Be the first to comment!