```ts
function topologicalSort(nodes: readonly string[], edges: readonly (readonly [string, string])[]): string[] {
    const inDegrees = new Map<string, number>();
    nodes.forEach(node => inDegrees.set(node, 0));

    edges.forEach(([from, to]) => {
        if (!nodes.includes(from) || !nodes.includes(to)) {
            throw Error(`Error: Node "${from}" or "${to}" is not in the list.`);
        }
        inDegrees.set(to, (inDegrees.get(to) ?? 0) + 1);
    });

    const queue: string[] = Array.from(nodes).filter(node => inDegrees.get(node) === 0);

    if (!queue.length) {
        throw new Error('Error: No nodes are zero-degrees initially.');
    }

    const ordering: string[] = [];
    while (queue.length > 0) {
        const currentNode = queue.shift()!;
        ordering.push(currentNode);
        nodes.splice(nodes.indexOf(currentNode), 1);

        edges.forEach(([from, to]) => {
            if (currentNode === from && inDegrees.has(to)) {
                const newInDegreeForTo = inDegrees.get(to)! - 1;
                inDegrees.set(to, newInDegreeForTo);
                if (newInDegreeForTo === 0) {
                    queue.push(to);
                }
            }
        });
    }

    if (nodes.length > 0 || !inDegrees.every(value => value === 0)) {
        const cycleNodes = nodes.filter(node => inDegrees.get(node) !== 0).join(', ');
        throw new Error(`Error: Cycle Found: ${cycleNodes}.`);
    }

    return ordering;
}
```